diff options
261 files changed, 14077 insertions, 193491 deletions
@@ -1,5 +1,7 @@ soong_namespace { - imports: ["hardware/google/interfaces"], + imports: [ + "hardware/google/interfaces", + ], } package { diff --git a/HardwareInfo/HardwareInfo.mk b/HardwareInfo/HardwareInfo.mk new file mode 100644 index 00000000..91d54a0e --- /dev/null +++ b/HardwareInfo/HardwareInfo.mk @@ -0,0 +1,2 @@ +PRODUCT_PACKAGES_DEBUG += HardwareInfo +BOARD_SEPOLICY_DIRS += hardware/google/pixel-sepolicy/hardware_info_app diff --git a/atrace/Android.bp b/atrace/Android.bp index 08ca1259..d3a1f402 100644 --- a/atrace/Android.bp +++ b/atrace/Android.bp @@ -17,22 +17,21 @@ package { default_applicable_licenses: ["Android-Apache-2.0"], } -cc_binary { - name: "android.hardware.atrace@1.0-service.pixel", - defaults: ["hidl_defaults"], - relative_install_path: "hw", - vendor: true, - init_rc: ["android.hardware.atrace@1.0-service.pixel.rc"], - vintf_fragments: ["android.hardware.atrace@1.0-service.pixel.xml"], +genrule { + name: "atrace_categories.rc.pixel", + tool_files: ["generate_rc.py"], + out: ["atrace_categories.rc"], srcs: [ - "AtraceDevice.cpp", - "service.cpp", - ], - shared_libs: [ - "liblog", - "libbase", - "libutils", - "libhidlbase", - "android.hardware.atrace@1.0", + "atrace_categories.txt", ], + cmd: "$(location generate_rc.py) $(in) > $(out)", +} + +prebuilt_etc { + name: "atrace_categories.txt.pixel", + filename: "atrace_categories.txt", + init_rc: [":atrace_categories.rc.pixel"], + src: "atrace_categories.txt", + sub_dir: "atrace", + vendor: true, } diff --git a/atrace/AtraceDevice.cpp b/atrace/AtraceDevice.cpp deleted file mode 100644 index 5f8b9cd9..00000000 --- a/atrace/AtraceDevice.cpp +++ /dev/null @@ -1,149 +0,0 @@ -/* - * Copyright (C) 2019 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. - */ - -#include <android-base/file.h> -#include <android-base/logging.h> -#include <android-base/stringprintf.h> - -#include "AtraceDevice.h" - -namespace android { -namespace hardware { -namespace atrace { -namespace V1_0 { -namespace implementation { - -using ::android::hardware::atrace::V1_0::Status; -using ::android::hardware::atrace::V1_0::TracingCategory; - -struct TracingConfig { - std::string description; - // path and if error on failure - std::vector<std::pair<std::string, bool>> paths; -}; - -// This is a map stores categories and their tracefs event name with required flags -const std::map<std::string, TracingConfig> kTracingMap = { - { - "gfx", - {"Graphics", - {{"mdss", false}, - {"sde", false}, - {"dpu", false}, - {"g2d", false}, - {"mali", false}}}, - }, - { - "memory", - {"Memory", {{"fastrpc/fastrpc_dma_stat", false}, {"dmabuf_heap", false}}}, - }, - { - "ion", - {"ION Allocation", {{"kmem/ion_alloc_buffer_start", false}}}, - }, - { - "sched", - {"CPU Scheduling and Trustzone", {{"scm", false}, {"systrace", false}}}, - }, - { - "freq", - {"CPU Frequency and System Clock", {{"msm_bus", false}}}, - }, - { - "thermal_tj", - {"Tj power limits and frequency", - {{"lmh/lmh_dcvs_freq", false}, - {"thermal_exynos", false}, - {"thermal_exynos_gpu", false}}}, - }, -}; - -// Methods from ::android::hardware::atrace::V1_0::IAtraceDevice follow. -Return<void> AtraceDevice::listCategories(listCategories_cb _hidl_cb) { - hidl_vec<TracingCategory> categories; - categories.resize(kTracingMap.size()); - std::size_t i = 0; - for (auto &c : kTracingMap) { - categories[i].name = c.first; - categories[i].description = c.second.description; - i++; - } - _hidl_cb(categories); - return Void(); -} - -AtraceDevice::AtraceDevice() { - struct stat st; - - mTracefsEventRoot = "/sys/kernel/tracing/events/"; - if (stat(mTracefsEventRoot.c_str(), &st) != 0) { - mTracefsEventRoot = "/sys/kernel/debug/tracing/events/"; - CHECK(stat(mTracefsEventRoot.c_str(), &st) == 0) << "tracefs must be mounted at either" - "/sys/kernel/tracing or " - "/sys/kernel/debug/tracing"; - } -} - -Return<::android::hardware::atrace::V1_0::Status> AtraceDevice::enableCategories( - const hidl_vec<hidl_string> &categories) { - if (!categories.size()) { - return Status::ERROR_INVALID_ARGUMENT; - } - - for (auto &c : categories) { - if (kTracingMap.count(c)) { - for (auto &p : kTracingMap.at(c).paths) { - std::string tracefs_event_enable_path = android::base::StringPrintf( - "%s%s/enable", mTracefsEventRoot.c_str(), p.first.c_str()); - if (!android::base::WriteStringToFile("1", tracefs_event_enable_path)) { - LOG(ERROR) << "Failed to enable tracing on: " << tracefs_event_enable_path; - if (p.second) { - // disable before return - disableAllCategories(); - return Status::ERROR_TRACING_POINT; - } - } - } - } else { - return Status::ERROR_INVALID_ARGUMENT; - } - } - return Status::SUCCESS; -} - -Return<::android::hardware::atrace::V1_0::Status> AtraceDevice::disableAllCategories() { - auto ret = Status::SUCCESS; - - for (auto &c : kTracingMap) { - for (auto &p : c.second.paths) { - std::string tracefs_event_enable_path = android::base::StringPrintf( - "%s%s/enable", mTracefsEventRoot.c_str(), p.first.c_str()); - if (!android::base::WriteStringToFile("0", tracefs_event_enable_path)) { - LOG(ERROR) << "Failed to disable tracing on: " << tracefs_event_enable_path; - if (p.second) { - ret = Status::ERROR_TRACING_POINT; - } - } - } - } - return ret; -} - -} // namespace implementation -} // namespace V1_0 -} // namespace atrace -} // namespace hardware -} // namespace android diff --git a/atrace/AtraceDevice.h b/atrace/AtraceDevice.h deleted file mode 100644 index 2863cd3b..00000000 --- a/atrace/AtraceDevice.h +++ /dev/null @@ -1,53 +0,0 @@ -/* - * Copyright (C) 2019 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. - */ - -#pragma once - -#include <android/hardware/atrace/1.0/IAtraceDevice.h> -#include <hidl/Status.h> - -namespace android { -namespace hardware { -namespace atrace { -namespace V1_0 { -namespace implementation { - -using ::android::sp; -using ::android::hardware::hidl_array; -using ::android::hardware::hidl_memory; -using ::android::hardware::hidl_string; -using ::android::hardware::hidl_vec; -using ::android::hardware::Return; -using ::android::hardware::Void; - -struct AtraceDevice : public IAtraceDevice { - AtraceDevice(); - // Methods from ::android::hardware::atrace::V1_0::IAtraceDevice follow. - Return<void> listCategories(listCategories_cb _hidl_cb) override; - Return<::android::hardware::atrace::V1_0::Status> enableCategories( - const hidl_vec<hidl_string> &categories) override; - Return<::android::hardware::atrace::V1_0::Status> disableAllCategories() override; - - private: - std::string mTracefsEventRoot; - // Methods from ::android::hidl::base::V1_0::IBase follow. -}; - -} // namespace implementation -} // namespace V1_0 -} // namespace atrace -} // namespace hardware -} // namespace android diff --git a/atrace/android.hardware.atrace@1.0-service.pixel.rc b/atrace/android.hardware.atrace@1.0-service.pixel.rc deleted file mode 100644 index 7d2a50db..00000000 --- a/atrace/android.hardware.atrace@1.0-service.pixel.rc +++ /dev/null @@ -1,46 +0,0 @@ -on late-init - # vendor graphics trace points - chmod 0666 /sys/kernel/debug/tracing/events/sde/enable - chmod 0666 /sys/kernel/tracing/events/sde/enable - chmod 0666 /sys/kernel/debug/tracing/events/mdss/enable - chmod 0666 /sys/kernel/tracing/events/mdss/enable - chmod 0666 /sys/kernel/debug/tracing/events/dpu/enable - chmod 0666 /sys/kernel/tracing/events/dpu/enable - chmod 0666 /sys/kernel/debug/tracing/events/g2d/enable - chmod 0666 /sys/kernel/tracing/events/g2d/enable - chmod 0666 /sys/kernel/debug/tracing/events/mali/enable - chmod 0666 /sys/kernel/tracing/events/mali/enable - - # ion allocation trace point - chmod 0666 /sys/kernel/debug/tracing/events/kmem/ion_alloc_buffer_start/enable - chmod 0666 /sys/kernel/tracing/events/kmem/ion_alloc_buffer_start/enable - # scm trace point - chmod 0666 /sys/kernel/debug/tracing/events/scm/enable - chmod 0666 /sys/kernel/tracing/events/scm/enable - # system bus clk trace point - chmod 0666 /sys/kernel/debug/tracing/events/msm_bus/enable - chmod 0666 /sys/kernel/tracing/events/msm_bus/enable - # legacy systrace point - chmod 0666 /sys/kernel/debug/tracing/events/systrace/enable - chmod 0666 /sys/kernel/tracing/events/systrace/enable - # qct hw lmh-dcvs - chmod 0666 /sys/kernel/debug/tracing/events/lmh/lmh_dcvs_freq/enable - chmod 0666 /sys/kernel/tracing/events/lmh/lmh_dcvs_freq/enable - # qct fastrpc dma buffers - chmod 0666 /sys/kernel/debug/tracing/events/fastrpc/fastrpc_dma_stat/enable - chmod 0666 /sys/kernel/tracing/events/fastrpc/fastrpc_dma_stat/enable - # dmabuf heap stats - chmod 0666 /sys/kernel/tracing/events/dmabuf_heap/enable - # Tj pid control loop trace points - chmod 0666 /sys/kernel/debug/tracing/events/thermal_exynos/enable - chmod 0666 /sys/kernel/tracing/events/thermal_exynos/enable - chmod 0666 /sys/kernel/debug/tracing/events/thermal_exynos_gpu/enable - chmod 0666 /sys/kernel/tracing/events/thermal_exynos_gpu/enable - -service vendor.atrace-hal-1-0 /vendor/bin/hw/android.hardware.atrace@1.0-service.pixel - interface android.hardware.atrace@1.0::IAtraceDevice default - class early_hal - user system - group system readtracefs - oneshot - disabled diff --git a/atrace/android.hardware.atrace@1.0-service.pixel.xml b/atrace/android.hardware.atrace@1.0-service.pixel.xml deleted file mode 100644 index fd3631ca..00000000 --- a/atrace/android.hardware.atrace@1.0-service.pixel.xml +++ /dev/null @@ -1,11 +0,0 @@ -<manifest version="1.0" type="device"> - <hal format="hidl"> - <name>android.hardware.atrace</name> - <transport>hwbinder</transport> - <version>1.0</version> - <interface> - <name>IAtraceDevice</name> - <instance>default</instance> - </interface> - </hal> -</manifest> diff --git a/atrace/atrace_categories.txt b/atrace/atrace_categories.txt new file mode 100644 index 00000000..7167c5be --- /dev/null +++ b/atrace/atrace_categories.txt @@ -0,0 +1,68 @@ +gfx + sde/sde_cmd_release_bw + sde/sde_encoder_underrun + sde/sde_evtlog + sde/sde_perf_calc_crtc + sde/sde_perf_crtc_update + sde/sde_perf_set_ot + sde/sde_perf_set_qos_luts + sde/sde_perf_uidle_cntr + sde/sde_perf_uidle_status + sde/sde_perf_update_bus + sde/tracing_mark_write + dpu/tracing_mark_write + g2d/g2d_perf_update_qos + g2d/tracing_mark_write + mali/gpu_power_state + mali/mali_jit_alloc + mali/mali_jit_free + mali/mali_jit_report + mali/mali_jit_report_gpu_mem + mali/mali_jit_report_pressure + mali/mali_jit_trim + mali/mali_jit_trim_from_region + mali/mali_job_slots_event + mali/mali_mmu_page_fault_grow + mali/mali_page_fault_insert_pages + mali/mali_pm_status + mali/mali_total_alloc_pages_change + mali/sysgraph + mali/sysgraph_gpu + mali/mali_KCPU_CQS_SET + mali/mali_KCPU_CQS_WAIT_BEGIN + mali/mali_KCPU_CQS_WAIT_END +memory + fastrpc/fastrpc_dma_stat + dmabuf_heap/dma_heap_stat + cma/cma_alloc_start + cma/cma_alloc_info +ion + kmem/ion_alloc_buffer_start +sched + scm/scm_call_start + scm/scm_call_end + systrace/0 +freq + msm_bus/bus_rules_matches +thermal_tj + lmh/lmh_dcvs_freq + thermal_exynos/thermal_cpu_pressure + thermal_exynos/thermal_exynos_allow_max_power + thermal_exynos/thermal_exynos_acpm_bulk + thermal_exynos/thermal_exynos_acpm_high_overhead + thermal_exynos/thermal_exynos_arm_update + thermal_exynos/thermal_exynos_cpu_pause + thermal_exynos/thermal_exynos_hard_limit_cdev_update + thermal_exynos/thermal_exynos_power_allocator + thermal_exynos/thermal_exynos_power_allocator_pid + thermal_exynos/thermal_exynos_power_cpu_get_power + thermal_exynos/thermal_exynos_power_cpu_limit + thermal_exynos/thermal_exynos_power_gpu_get_power + thermal_exynos/thermal_exynos_power_gpu_limit + thermal_exynos/thermal_exynos_tpu_pause + thermal_exynos/vendor_cdev_update + thermal_exynos_gpu/thermal_exynos_power_gpu_get_power + thermal_exynos_gpu/thermal_exynos_power_gpu_limit + thermal_exynos_gpu/vendor_cdev_update +camera + lwis/tracing_mark_write diff --git a/atrace/generate_rc.py b/atrace/generate_rc.py new file mode 100755 index 00000000..e18a734e --- /dev/null +++ b/atrace/generate_rc.py @@ -0,0 +1,21 @@ +#!/usr/bin/env python3 + +import argparse + +parser = argparse.ArgumentParser("generate_rc.py", description="Generates an .rc files that fixes the permissions for all the ftrace events listed in the input atrace_categories.txt file") +parser.add_argument("filename", help="Path to the atrace_categories.txt file") + +args = parser.parse_args() + +print("# Sets permission for vendor ftrace events") +print("on late-init") + +with open(args.filename, 'r') as f: + for line in f: + line = line.rstrip('\n') + if line.startswith(' ') or line.startswith('\t'): + path = line.lstrip(" \t") + print(" chmod 0666 /sys/kernel/debug/tracing/events/{}/enable".format(path)) + print(" chmod 0666 /sys/kernel/tracing/events/{}/enable".format(path)) + else: + print (" # {} trace points".format(line)) diff --git a/atrace/service.cpp b/atrace/service.cpp deleted file mode 100644 index f510325b..00000000 --- a/atrace/service.cpp +++ /dev/null @@ -1,45 +0,0 @@ -/* - * Copyright (C) 2019 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 "android.hardware.atrace@1.0-service.pixel" - -#include <hidl/HidlLazyUtils.h> -#include <hidl/HidlSupport.h> -#include <hidl/HidlTransportSupport.h> - -#include "AtraceDevice.h" - -using ::android::OK; -using ::android::sp; -using ::android::hardware::configureRpcThreadpool; -using ::android::hardware::joinRpcThreadpool; -using ::android::hardware::LazyServiceRegistrar; -using ::android::hardware::atrace::V1_0::IAtraceDevice; -using ::android::hardware::atrace::V1_0::implementation::AtraceDevice; - -int main(int /* argc */, char * /* argv */ []) { - sp<IAtraceDevice> atrace = new AtraceDevice; - configureRpcThreadpool(1, true /* will join */); - auto serviceRegistrar = LazyServiceRegistrar::getInstance(); - if (serviceRegistrar.registerService(atrace) != OK) { - ALOGE("Could not register service."); - return 1; - } - joinRpcThreadpool(); - - ALOGE("Service exited!"); - return 1; -} diff --git a/battery_mitigation/Android.bp b/battery_mitigation/Android.bp new file mode 100644 index 00000000..1a5d6c6e --- /dev/null +++ b/battery_mitigation/Android.bp @@ -0,0 +1,46 @@ +// +// Copyright (C) 2022 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. +// + +package { + default_applicable_licenses: ["Android-Apache-2.0"], +} + +cc_library { + name: "libpixelmitigation", + export_include_dirs: ["include"], + vendor_available: true, + srcs: [ + "BatteryMitigation.cpp", + "MitigationThermalManager.cpp", + ], + static_libs: [ + "libmath", + ], + + shared_libs: [ + "libbase", + "libbinder_ndk", + "libcutils", + "libhardware", + "liblog", + "libutils", + "android.hardware.thermal-V1-ndk" + ], + cflags: [ + "-Wall", + "-Werror", + ], +} diff --git a/battery_mitigation/BatteryMitigation.cpp b/battery_mitigation/BatteryMitigation.cpp new file mode 100644 index 00000000..98419fc5 --- /dev/null +++ b/battery_mitigation/BatteryMitigation.cpp @@ -0,0 +1,67 @@ +/* + * Copyright (C) 2022 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. + */ + +#include <battery_mitigation/BatteryMitigation.h> + +#include <sstream> + +#define MAX_BROWNOUT_DATA_AGE_SECONDS 300 + +namespace android { +namespace hardware { +namespace google { +namespace pixel { + +BatteryMitigation::BatteryMitigation(const struct MitigationConfig::Config &cfg) { + mThermalMgr = &MitigationThermalManager::getInstance(); + mThermalMgr->updateConfig(cfg); +} + +bool BatteryMitigation::isMitigationLogTimeValid(std::chrono::system_clock::time_point startTime, + const char *const logFilePath, + const char *const timestampFormat, + const std::regex pattern) { + std::string logFile; + if (!android::base::ReadFileToString(logFilePath, &logFile)) { + return false; + } + std::istringstream content(logFile); + std::string line; + int counter = 0; + std::smatch pattern_match; + while (std::getline(content, line)) { + if (std::regex_match(line, pattern_match, pattern)) { + std::tm triggeredTimestamp = {}; + std::istringstream ss(pattern_match.str()); + ss >> std::get_time(&triggeredTimestamp, timestampFormat); + auto logFileTime = std::chrono::system_clock::from_time_t(mktime(&triggeredTimestamp)); + auto delta = std::chrono::duration_cast<std::chrono::seconds>(startTime - logFileTime); + if ((delta.count() < MAX_BROWNOUT_DATA_AGE_SECONDS) && (delta.count() > 0)) { + return true; + } + } + counter += 1; + if (counter > 5) { + break; + } + } + return false; +} + +} // namespace pixel +} // namespace google +} // namespace hardware +} // namespace android diff --git a/battery_mitigation/MitigationThermalManager.cpp b/battery_mitigation/MitigationThermalManager.cpp new file mode 100644 index 00000000..42e6e3cb --- /dev/null +++ b/battery_mitigation/MitigationThermalManager.cpp @@ -0,0 +1,189 @@ +/* + * Copyright (C) 2022 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 "mitigation-logger" + +#include <android-base/chrono_utils.h> +#include <android-base/file.h> +#include <android-base/logging.h> +#include <android/binder_manager.h> +#include <android/binder_process.h> +#include <battery_mitigation/MitigationThermalManager.h> +#include <errno.h> +#include <utils/Log.h> + +#include <chrono> +#include <ctime> +#include <iomanip> +#include <iostream> +#include <string> +#include <thread> + +#define NUM_OF_SAMPLES 20 +#define CAPTURE_INTERVAL_S 2 /* 2 seconds between new capture */ + +namespace android { +namespace hardware { +namespace google { +namespace pixel { + +MitigationThermalManager &MitigationThermalManager::getInstance() { + static MitigationThermalManager mitigationThermalManager; + return mitigationThermalManager; +} + +void MitigationThermalManager::remove() { + const std::lock_guard<std::mutex> lock(thermal_hal_mutex_); + if (!thermal) { + return; + } + if (callback) { + auto ret = thermal->unregisterThermalChangedCallback(callback); + if (!ret.isOk()) { + LOG(ERROR) << "Failed to release thermal callback! " << ret.getMessage(); + } + } +} + +MitigationThermalManager::MitigationThermalManager() { + if (!ABinderProcess_isThreadPoolStarted()) { + // if no thread pool then the thermal callback will not work, so abort + LOG(ERROR) << "The user of MitigationThermalManager did not start a thread pool!"; + return; + } + if (!connectThermalHal()) { + remove(); + } +} + +MitigationThermalManager::~MitigationThermalManager() { + remove(); +} + +void MitigationThermalManager::updateConfig(const struct MitigationConfig::Config &cfg) { + kLogFilePath = std::string(cfg.LogFilePath); + kSystemPath = cfg.SystemPath; + kSystemName = cfg.SystemName; + kFilteredZones = cfg.FilteredZones; + kTimestampFormat = cfg.TimestampFormat; +} + +bool MitigationThermalManager::connectThermalHal() { + const std::string thermal_instance_name = + std::string(::aidl::android::hardware::thermal::IThermal::descriptor) + "/default"; + std::shared_ptr<aidl::android::hardware::thermal::IThermal> thermal_aidl_service; + const std::lock_guard<std::mutex> lock(thermal_hal_mutex_); + if (AServiceManager_isDeclared(thermal_instance_name.c_str())) { + thermal = ::aidl::android::hardware::thermal::IThermal::fromBinder( + ndk::SpAIBinder(AServiceManager_waitForService(thermal_instance_name.c_str()))); + lastCapturedTime = ::android::base::boot_clock::now(); + return registerCallback(); + } else { + LOG(ERROR) << "Thermal AIDL service is not declared"; + } + return false; +} + +bool MitigationThermalManager::isMitigationTemperature(const Temperature &temperature) { + if (std::find(kFilteredZones.begin(), kFilteredZones.end(), temperature.name) != + kFilteredZones.end()) { + return true; + } + return false; +} + +void MitigationThermalManager::thermalCb(const Temperature &temperature) { + if ((temperature.throttlingStatus == ThrottlingSeverity::NONE) || + (!isMitigationTemperature(temperature))) { + return; + } + auto currentTime = ::android::base::boot_clock::now(); + auto delta = + std::chrono::duration_cast<std::chrono::seconds>(currentTime - lastCapturedTime); + if (delta.count() < CAPTURE_INTERVAL_S) { + /* Do not log if delta is within 2 seconds */ + return; + } + int flag = O_WRONLY | O_CREAT | O_NOFOLLOW | O_CLOEXEC | O_APPEND | O_TRUNC; + android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(kLogFilePath.c_str(), flag, 0644))); + lastCapturedTime = currentTime; + std::stringstream oss; + oss << temperature.name << " triggered at " << temperature.value << std::endl << std::flush; + android::base::WriteStringToFd(oss.str(), fd); + fsync(fd); + + for (int i = 0; i < NUM_OF_SAMPLES; i++) { + auto now = std::chrono::system_clock::now(); + auto time_sec = std::chrono::system_clock::to_time_t(now); + auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()) - + std::chrono::duration_cast<std::chrono::seconds>(now.time_since_epoch()); + struct tm now_tm; + localtime_r(&time_sec, &now_tm); + oss << std::put_time(&now_tm, kTimestampFormat.c_str()) << "." << std::setw(3) + << std::setfill('0') << ms.count() << std::endl + << std::flush; + android::base::WriteStringToFd(oss.str(), fd); + fsync(fd); + oss.str(""); + /* log System info */ + for (int j = 0; j < kSystemName.size(); j++) { + std::string value; + bool result = android::base::ReadFileToString(kSystemPath[j], &value); + if (!result) { + LOG(ERROR) << "Could not read: " << kSystemName[j]; + } + android::base::WriteStringToFd(kSystemName[j] + ":" + value, fd); + } + } + fsync(fd); +} + +bool MitigationThermalManager::registerCallback() { + if (!thermal) { + LOG(ERROR) << "Unable to connect Thermal AIDL service"; + return false; + } + // Create thermal callback recipient object. + if (callback == nullptr) { + callback = + ndk::SharedRefBase::make<ThermalCallback>([this](const Temperature &temperature) { + std::lock_guard api_lock(thermal_callback_mutex_); + thermalCb(temperature); + }); + } + // Register thermal callback to thermal hal to cover all. Cannot register twice. + auto ret_callback = thermal->registerThermalChangedCallback(callback); + if (!ret_callback.isOk()) { + LOG(ERROR) << "Failed to register thermal callback! " << ret_callback.getMessage(); + return false; + } + + // Create AIDL thermal death recipient object. + if (aidlDeathRecipient.get() == nullptr) { + aidlDeathRecipient = ndk::ScopedAIBinder_DeathRecipient( + AIBinder_DeathRecipient_new(onThermalAidlBinderDied)); + } + auto linked = AIBinder_linkToDeath(thermal->asBinder().get(), aidlDeathRecipient.get(), this); + if (linked != STATUS_OK) { + // should we continue if the death recipient is not registered? + LOG(ERROR) << "Failed to register AIDL thermal death notification"; + } + return true; +} + +} // namespace pixel +} // namespace google +} // namespace hardware +} // namespace android diff --git a/battery_mitigation/OWNERS b/battery_mitigation/OWNERS new file mode 100644 index 00000000..363efac2 --- /dev/null +++ b/battery_mitigation/OWNERS @@ -0,0 +1,2 @@ +geolee@google.com +wvw@google.com diff --git a/power-libperfmgr/adaptivecpu/Device.h b/battery_mitigation/include/battery_mitigation/BatteryMitigation.h index 8e357a31..d3ce433d 100644 --- a/power-libperfmgr/adaptivecpu/Device.h +++ b/battery_mitigation/include/battery_mitigation/BatteryMitigation.h @@ -16,20 +16,29 @@ #pragma once -namespace aidl { -namespace google { +#include <utils/RefBase.h> + +#include "MitigationThermalManager.h" + +namespace android { namespace hardware { -namespace power { -namespace impl { +namespace google { namespace pixel { -enum class Device { UNKNOWN = 0, RAVEN = 1, ORIOLE = 2 }; +using ::android::sp; -Device ReadDevice(); +class BatteryMitigation : public RefBase { + public: + BatteryMitigation(const struct MitigationConfig::Config &cfg); + bool isMitigationLogTimeValid(std::chrono::system_clock::time_point startTime, + const char *const logFilePath, const char *const timestampFormat, + const std::regex pattern); + + private: + MitigationThermalManager *mThermalMgr; +}; } // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware } // namespace google -} // namespace aidl +} // namespace hardware +} // namespace android diff --git a/battery_mitigation/include/battery_mitigation/MitigationConfig.h b/battery_mitigation/include/battery_mitigation/MitigationConfig.h new file mode 100644 index 00000000..825e30c6 --- /dev/null +++ b/battery_mitigation/include/battery_mitigation/MitigationConfig.h @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2022 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. + */ + +#ifndef HARDWARE_GOOGLE_PIXEL_BATTERY_MITIGATION_CONFIG_H +#define HARDWARE_GOOGLE_PIXEL_BATTERY_MITIGATION_CONFIG_H + +namespace android { +namespace hardware { +namespace google { +namespace pixel { + +class MitigationConfig { + public: + struct Config { + const std::vector<std::string> SystemPath; + const std::vector<std::string> FilteredZones; + const std::vector<std::string> SystemName; + const char *const LogFilePath; + const char *const TimestampFormat; + }; + + MitigationConfig(const struct Config &cfg); + + private: + const std::vector<std::string> kSystemPath; + const std::vector<std::string> kFilteredZones; + const std::vector<std::string> kSystemName; + const char *const kLogFilePath; + const char *const kTimestampFormat; +}; + +} // namespace pixel +} // namespace google +} // namespace hardware +} // namespace android + +#endif // HARDWARE_GOOGLE_PIXEL_BATTERY_MITIGATION_CONFIG_H diff --git a/battery_mitigation/include/battery_mitigation/MitigationThermalManager.h b/battery_mitigation/include/battery_mitigation/MitigationThermalManager.h new file mode 100644 index 00000000..5b5a3f0a --- /dev/null +++ b/battery_mitigation/include/battery_mitigation/MitigationThermalManager.h @@ -0,0 +1,121 @@ +/* + * Copyright (C) 2022 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. + */ + +#pragma once + +#ifndef MITIGATION_THERMAL_MANAGER_H_ +#define MITIGATION_THERMAL_MANAGER_H_ + +#include <aidl/android/hardware/thermal/BnThermalChangedCallback.h> +#include <aidl/android/hardware/thermal/IThermal.h> +#include <android-base/chrono_utils.h> +#include <android-base/file.h> +#include <android-base/logging.h> +#include <android-base/parseint.h> +#include <android-base/properties.h> +#include <android-base/strings.h> +#include <android/binder_auto_utils.h> +#include <unistd.h> +#include <utils/Mutex.h> + +#include <fstream> +#include <iostream> +#include <regex> + +#include "MitigationConfig.h" + +namespace android { +namespace hardware { +namespace google { +namespace pixel { + +using ::aidl::android::hardware::thermal::BnThermalChangedCallback; +using ::aidl::android::hardware::thermal::IThermal; +using ::aidl::android::hardware::thermal::Temperature; +using ::aidl::android::hardware::thermal::TemperatureType; +using ::aidl::android::hardware::thermal::ThrottlingSeverity; +using android::hardware::google::pixel::MitigationConfig; + +class MitigationThermalManager { + public: + static MitigationThermalManager &getInstance(); + + // delete copy and move constructors and assign operators + MitigationThermalManager(MitigationThermalManager const &) = delete; + MitigationThermalManager(MitigationThermalManager &&) = delete; + MitigationThermalManager &operator=(MitigationThermalManager const &) = delete; + MitigationThermalManager &operator=(MitigationThermalManager &&) = delete; + + private: + // ThermalCallback implements the HIDL thermal changed callback + // interface, IThermalChangedCallback. + void thermalCb(const Temperature &temperature); + android::base::boot_clock::time_point lastCapturedTime; + + class ThermalCallback : public BnThermalChangedCallback { + public: + ThermalCallback(std::function<void(const Temperature &)> notify_function) + : notifyFunction(notify_function) {} + + // Callback function. thermal service will call this. + ndk::ScopedAStatus notifyThrottling(const Temperature &temperature) override { + if ((temperature.type == TemperatureType::BCL_VOLTAGE) || + (temperature.type == TemperatureType::BCL_CURRENT)) { + notifyFunction(temperature); + } + return ndk::ScopedAStatus::ok(); + } + + private: + std::function<void(const Temperature &)> notifyFunction; + }; + + static void onThermalAidlBinderDied(void *) { + LOG(ERROR) << "Thermal AIDL service died, trying to reconnect"; + MitigationThermalManager::getInstance().connectThermalHal(); + } + + public: + MitigationThermalManager(); + ~MitigationThermalManager(); + bool connectThermalHal(); + bool isMitigationTemperature(const Temperature &temperature); + bool registerCallback(); + void remove(); + void updateConfig(const struct MitigationConfig::Config &cfg); + + + private: + std::mutex thermal_callback_mutex_; + std::mutex thermal_hal_mutex_; + // Thermal hal interface. + std::shared_ptr<IThermal> thermal; + // Thermal hal callback object. + std::shared_ptr<ThermalCallback> callback; + // Receiver when AIDL thermal hal restart. + ndk::ScopedAIBinder_DeathRecipient aidlDeathRecipient; + std::vector<std::string> kSystemPath; + std::vector<std::string> kFilteredZones; + std::vector<std::string> kSystemName; + std::string kLogFilePath; + std::string kTimestampFormat; +}; + +} // namespace pixel +} // namespace google +} // namespace hardware +} // namespace android +#endif diff --git a/citadel/citadel.mk b/citadel/citadel.mk index c66fc1fb..fa7c5c31 100644 --- a/citadel/citadel.mk +++ b/citadel/citadel.mk @@ -1,14 +1,19 @@ +PRODUCT_SOONG_NAMESPACES += vendor/google_nos/init/citadel # Citadel PRODUCT_PACKAGES += \ citadeld \ citadel_updater \ android.hardware.authsecret@1.0-service.citadel \ + android.hardware.authsecret-service.citadel \ android.hardware.oemlock@1.0-service.citadel \ + android.hardware.oemlock-service.citadel \ android.hardware.weaver@1.0-service.citadel \ + android.hardware.weaver-service.citadel \ android.hardware.keymaster@4.1-service.citadel \ android.hardware.identity@1.0-service.citadel \ android.hardware.fastboot@1.1-impl.pixel \ - wait_for_strongbox + wait_for_strongbox \ + init_citadel # Citadel debug stuff PRODUCT_PACKAGES_DEBUG += \ @@ -18,9 +23,6 @@ PRODUCT_PACKAGES_DEBUG += \ PRODUCT_PACKAGES += \ android.hardware.rebootescrow-service.citadel -# init scripts (won't be in AOSP) --include vendor/google_nos/init/citadel/init.mk - ifneq ($(wildcard vendor/google_nos/provision),) PRODUCT_PACKAGES_DEBUG += CitadelProvision @@ -37,3 +39,10 @@ endif # Sepolicy BOARD_SEPOLICY_DIRS += hardware/google/pixel-sepolicy/citadel + +# USERDEBUG ONLY: Install test packages +ifneq (,$(filter userdebug eng,$(TARGET_BUILD_VARIANT))) +PRODUCT_PACKAGES_DEBUG += citadel_integration_tests \ + pwntest \ + nugget_targeted_tests +endif diff --git a/common/pixel-common-device.mk b/common/pixel-common-device.mk index 4bb43981..d191c46a 100644 --- a/common/pixel-common-device.mk +++ b/common/pixel-common-device.mk @@ -8,9 +8,9 @@ SYSTEM_EXT_PRIVATE_SEPOLICY_DIRS += hardware/google/pixel-sepolicy/common/system PRODUCT_PACKAGES += \ misc_writer -# Enable atrace hal and tools for pixel devices +# Enable atrace categories and tools for pixel devices PRODUCT_PACKAGES += \ - android.hardware.atrace@1.0-service.pixel \ + atrace_categories.txt.pixel \ dmabuf_dump # fastbootd @@ -20,7 +20,19 @@ PRODUCT_PACKAGES += \ # Common ramdump file type. BOARD_VENDOR_SEPOLICY_DIRS += hardware/google/pixel-sepolicy/ramdump/common +# Enable RKP support +PRODUCT_PRODUCT_PROPERTIES += \ + remote_provisioning.hostname=remoteprovisioning.googleapis.com + # Pixel Experience + +ifneq (,$(filter userdebug eng, $(TARGET_BUILD_VARIANT))) +ifeq (,$(filter aosp_%,$(TARGET_PRODUCT))) +PRODUCT_PACKAGES_DEBUG += wifi_diagnostic +BOARD_VENDOR_SEPOLICY_DIRS += hardware/google/pixel-sepolicy/wifi_diagnostic +endif +endif + PRODUCT_PACKAGES_DEBUG += wifi_sniffer BOARD_VENDOR_SEPOLICY_DIRS += hardware/google/pixel-sepolicy/wifi_sniffer @@ -31,3 +43,21 @@ BOARD_VENDOR_SEPOLICY_DIRS += hardware/google/pixel-sepolicy/wifi_perf_diag # but also allow explicit overriding for testing and development. SYSTEM_OPTIMIZE_JAVA ?= true SYSTEMUI_OPTIMIZE_JAVA ?= true + +# Exclude features that are not available on AOSP devices. +ifneq (,$(filter aosp_%,$(TARGET_PRODUCT))) +PRODUCT_COPY_FILES += \ + frameworks/native/data/etc/aosp_excluded_hardware.xml:$(TARGET_COPY_OUT_VENDOR)/etc/permissions/aosp_excluded_hardware.xml +endif + +# Preopt SystemUI +PRODUCT_DEXPREOPT_SPEED_APPS += SystemUIGoogle # For internal +PRODUCT_DEXPREOPT_SPEED_APPS += SystemUI # For AOSP + +# Compile SystemUI on device with `speed`. +PRODUCT_PROPERTY_OVERRIDES += \ + dalvik.vm.systemuicompilerfilter=speed + +# Virtual fingerprint HAL +PRODUCT_PACKAGES_DEBUG += android.hardware.biometrics.fingerprint-service.example + diff --git a/dauntless/dauntless.mk b/dauntless/dauntless.mk deleted file mode 100644 index d0835004..00000000 --- a/dauntless/dauntless.mk +++ /dev/null @@ -1,20 +0,0 @@ -# Dauntless -PRODUCT_PACKAGES += \ - citadeld \ - citadel_updater \ - android.hardware.weaver@1.0-service.citadel \ - android.hardware.identity@1.0-service.citadel - -# AIDL -PRODUCT_PACKAGES += \ - android.hardware.security.keymint-service.citadel - -PRODUCT_COPY_FILES += \ - hardware/google/pixel/dauntless/android.hardware.strongbox_keystore.xml:$(TARGET_COPY_OUT_VENDOR)/etc/permissions/android.hardware.strongbox_keystore.xml - -# init scripts (won't be in AOSP) --include vendor/google_nos/init/dauntless/init.mk - -ifneq ($(wildcard vendor/google_nos/provision),) -PRODUCT_PACKAGES_DEBUG += CitadelProvision -endif diff --git a/dynamic_partitions/Android.bp b/dynamic_partitions/Android.bp index a5e54a9c..6ce402d0 100644 --- a/dynamic_partitions/Android.bp +++ b/dynamic_partitions/Android.bp @@ -20,6 +20,6 @@ package { sh_binary { name: "check_dynamic_partitions", - src: "check_dynamic_partitions", + src: "check_dynamic_partitions.sh", product_specific: true, } diff --git a/dynamic_partitions/check_dynamic_partitions b/dynamic_partitions/check_dynamic_partitions.sh index 13733c7d..13733c7d 100755 --- a/dynamic_partitions/check_dynamic_partitions +++ b/dynamic_partitions/check_dynamic_partitions.sh diff --git a/fastboot/Android.bp b/fastboot/Android.bp index dd2f80da..ee1cda34 100644 --- a/fastboot/Android.bp +++ b/fastboot/Android.bp @@ -42,3 +42,31 @@ cc_library { "libfstab", ], } + + +cc_binary { + name: "android.hardware.fastboot-service.pixel_recovery", + init_rc: ["android.hardware.fastboot-service.pixel_recovery.rc"], + vintf_fragments: ["android.hardware.fastboot-service.pixel.xml"], + recovery: true, + srcs: [ + "Fastboot_aidl.cpp", + "main.cpp", + ], + relative_install_path: "hw", + shared_libs: [ + "android.hardware.fastboot-V1-ndk", + "libbinder_ndk", + "libbase", + "libcutils", + "libext4_utils", + "libfs_mgr", + "liblog", + "libutils", + ], + static_libs: [ + "libnos_for_fastboot", + "libnos_citadel_for_fastboot", + "libfstab", + ], +} diff --git a/fastboot/Fastboot.cpp b/fastboot/Fastboot.cpp index 922334b4..913d82d0 100644 --- a/fastboot/Fastboot.cpp +++ b/fastboot/Fastboot.cpp @@ -16,15 +16,16 @@ #include "fastboot/Fastboot.h" -#include <string> -#include <unordered_map> -#include <vector> -#include <map> - #include <android-base/file.h> #include <android-base/logging.h> #include <android-base/strings.h> #include <android-base/unique_fd.h> +#include <dlfcn.h> + +#include <map> +#include <string> +#include <unordered_map> +#include <vector> // FS headers #include <ext4_utils/wipe.h> @@ -169,11 +170,35 @@ enum WipeVolumeStatus wipe_volume(const std::string &volume) { return WIPE_OK; } +// Attempt to reuse a WipeKeys function that might be found in the recovery +// library in order to clear any digital car keys on the secure element. +bool WipeDigitalCarKeys(void) { + static constexpr const char *kDefaultLibRecoveryUIExt = "librecovery_ui_ext.so"; + void *librecovery_ui_ext = dlopen(kDefaultLibRecoveryUIExt, RTLD_NOW); + if (librecovery_ui_ext == nullptr) { + // Dynamic library not found. Returning true since this likely + // means target does not support DCK. + return true; + } + + bool *(*WipeKeysFunc)(void *const); + reinterpret_cast<void *&>(WipeKeysFunc) = dlsym(librecovery_ui_ext, "WipeKeys"); + if (WipeKeysFunc == nullptr) { + // No WipeKeys implementation found. Returning true since this likely + // means target does not support DCK. + return true; + } + + return (*WipeKeysFunc)(nullptr); +} + Return<void> Fastboot::doOemSpecificErase(V1_1::IFastboot::doOemSpecificErase_cb _hidl_cb) { // Erase metadata partition along with userdata partition. // Keep erasing Titan M even if failing on this case. auto wipe_status = wipe_volume("/metadata"); + bool dck_wipe_success = WipeDigitalCarKeys(); + // Connect to Titan M ::nos::NuggetClient client; client.Open(); @@ -188,19 +213,27 @@ Return<void> Fastboot::doOemSpecificErase(V1_1::IFastboot::doOemSpecificErase_cb memcpy(magic.data(), &magicValue, sizeof(magicValue)); const uint8_t retry_count = 5; uint32_t nugget_status; - for(uint8_t i = 0; i < retry_count; i++) { + for (uint8_t i = 0; i < retry_count; i++) { nugget_status = client.CallApp(APP_ID_NUGGET, NUGGET_PARAM_NUKE_FROM_ORBIT, magic, nullptr); - if (nugget_status == APP_SUCCESS && wipe_status == WIPE_OK) { + if (nugget_status == APP_SUCCESS && wipe_status == WIPE_OK && dck_wipe_success) { _hidl_cb({Status::SUCCESS, wipe_vol_ret_msg[wipe_status]}); return Void(); } } // Return exactly what happened - if (nugget_status != APP_SUCCESS && wipe_status != WIPE_OK) { + if (nugget_status != APP_SUCCESS && wipe_status != WIPE_OK && !dck_wipe_success) { + _hidl_cb({Status::FAILURE_UNKNOWN, "Fail on wiping metadata, Titan M user data, and DCK"}); + } else if (nugget_status != APP_SUCCESS && wipe_status != WIPE_OK) { _hidl_cb({Status::FAILURE_UNKNOWN, "Fail on wiping metadata and Titan M user data"}); + } else if (nugget_status != APP_SUCCESS && !dck_wipe_success) { + _hidl_cb({Status::FAILURE_UNKNOWN, "Titan M user data and DCK wipe failed"}); } else if (nugget_status != APP_SUCCESS) { _hidl_cb({Status::FAILURE_UNKNOWN, "Titan M user data wipe failed"}); + } else if (wipe_status != WIPE_OK && !dck_wipe_success) { + _hidl_cb({Status::FAILURE_UNKNOWN, "Fail on wiping metadata and DCK"}); + } else if (!dck_wipe_success) { + _hidl_cb({Status::FAILURE_UNKNOWN, "DCK wipe failed"}); } else { if (wipe_vol_ret_msg.find(wipe_status) != wipe_vol_ret_msg.end()) _hidl_cb({Status::FAILURE_UNKNOWN, wipe_vol_ret_msg[wipe_status]}); diff --git a/fastboot/Fastboot_aidl.cpp b/fastboot/Fastboot_aidl.cpp new file mode 100644 index 00000000..32df5f36 --- /dev/null +++ b/fastboot/Fastboot_aidl.cpp @@ -0,0 +1,293 @@ +/* + * Copyright (C) 2022 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. + */ +#include "include/fastboot/Fastboot_aidl.h" + +#include <android-base/file.h> +#include <android-base/logging.h> +#include <android-base/strings.h> +#include <android-base/unique_fd.h> +#include <dlfcn.h> +#include <endian.h> + +#include <map> +#include <string> +#include <unordered_map> +#include <vector> + +// FS headers +#include <ext4_utils/wipe.h> +#include <fs_mgr.h> +#include <fs_mgr/roots.h> + +// Nugget headers +#include <app_nugget.h> +#include <nos/NuggetClient.h> +#include <nos/debug.h> + +using ndk::ScopedAStatus; + +namespace aidl { +namespace android { +namespace hardware { +namespace fastboot { + +constexpr const char *BRIGHTNESS_FILE = "/sys/class/backlight/panel0-backlight/brightness"; +constexpr int DISPLAY_BRIGHTNESS_DIM_THRESHOLD = 20; + +using OEMCommandHandler = + std::function<ScopedAStatus(const std::vector<std::string> &, std::string *)>; + +ScopedAStatus Fastboot::getPartitionType(const std::string &in_partitionName, + FileSystemType *_aidl_return) { + if (in_partitionName.empty()) { + return ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT, + "Invalid partition name"); + } + // For bluecross devices, all partitions need to return raw. + *_aidl_return = FileSystemType::RAW; + return ScopedAStatus::ok(); +} + +ScopedAStatus Fastboot::getVariant(std::string *_aidl_return) { + *_aidl_return = "MSM USF"; + return ScopedAStatus::ok(); +} + +ScopedAStatus Fastboot::getOffModeChargeState(bool *_aidl_return) { + constexpr const char *kDevinfoPath = "/dev/block/by-name/devinfo"; + constexpr int kDevInfoOffModeChargeOffset = 15; + + uint8_t off_mode_charge_status = 0; + ::android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(kDevinfoPath, O_RDONLY | O_BINARY))); + if (fd < 0) { + std::string message = "Unable to open devinfo " + std::to_string(errno); + return ScopedAStatus::fromServiceSpecificErrorWithMessage(BnFastboot::FAILURE_UNKNOWN, + message.c_str()); + } + auto ret = ::android::base::ReadFullyAtOffset(fd, &off_mode_charge_status, 1 /* byte count */, + kDevInfoOffModeChargeOffset); + if (!ret) { + std::string message = "Reading devifo failed errno:" + std::to_string(errno) + + " Unable to read off-mode-charge state"; + return ScopedAStatus::fromServiceSpecificErrorWithMessage(BnFastboot::FAILURE_UNKNOWN, + message.c_str()); + } else { + *_aidl_return = (off_mode_charge_status != 0); + } + + return ScopedAStatus::ok(); +} + +ScopedAStatus Fastboot::getBatteryVoltageFlashingThreshold(int32_t *_aidl_return) { + constexpr int kMinVoltageForFlashing = 3500; + *_aidl_return = kMinVoltageForFlashing; + return ScopedAStatus::ok(); +} + +ScopedAStatus SetBrightnessLevel(const std::vector<std::string> &args, std::string *_aidl_return) { + if (!args.size()) { + return ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT, + "Brightness level unspecified"); + } + + auto level = std::stoi(args[0]); + + if (level < 0 || level > 100) { + return ScopedAStatus::fromExceptionCodeWithMessage( + EX_ILLEGAL_ARGUMENT, "Brighness level must be between 0 and 100"); + } + + // Avoid screen being dimmed too much. + if (level < DISPLAY_BRIGHTNESS_DIM_THRESHOLD) { + level = DISPLAY_BRIGHTNESS_DIM_THRESHOLD; + } + + if (::android::base::WriteStringToFile(std::to_string(level), BRIGHTNESS_FILE)) { + *_aidl_return = ""; + return ScopedAStatus::ok(); + } + std::string message = "Writing to brightness file failed errno: " + std::to_string(errno) + + " Unable to set display brightness"; + + return ScopedAStatus::fromServiceSpecificErrorWithMessage(BnFastboot::FAILURE_UNKNOWN, + message.c_str()); +} + +ScopedAStatus Fastboot::doOemCommand(const std::string &in_oemCmd, std::string *_aidl_return) { + const std::unordered_map<std::string, OEMCommandHandler> kOEMCmdMap = { + {FB_OEM_SET_BRIGHTNESS, SetBrightnessLevel}, + }; + + auto args = ::android::base::Split(in_oemCmd, " "); + if (args.size() < 2) { + return ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT, + "Invalid OEM command"); + } + + // args[0] will be "oem", args[1] will be the command name + auto cmd_handler = kOEMCmdMap.find(args[1]); + if (cmd_handler != kOEMCmdMap.end()) { + return cmd_handler->second(std::vector<std::string>(args.begin() + 2, args.end()), + _aidl_return); + } else { + return ScopedAStatus::fromServiceSpecificErrorWithMessage(BnFastboot::FAILURE_UNKNOWN, + "Unknown OEM Command"); + } + + return ScopedAStatus::ok(); +} + +static ::android::fs_mgr::Fstab fstab; +enum WipeVolumeStatus { + WIPE_OK = 0, + VOL_FSTAB, + VOL_UNKNOWN, + VOL_MOUNTED, + VOL_BLK_DEV_OPEN, + WIPE_ERROR_MAX = 0xffffffff, +}; +std::map<enum WipeVolumeStatus, std::string> wipe_vol_ret_msg{ + {WIPE_OK, ""}, + {VOL_FSTAB, "Unknown FS table"}, + {VOL_UNKNOWN, "Unknown volume"}, + {VOL_MOUNTED, "Fail to unmount volume"}, + {VOL_BLK_DEV_OPEN, "Fail to open block device"}, + {WIPE_ERROR_MAX, "Unknown wipe error"}}; + +enum WipeVolumeStatus wipe_volume(const std::string &volume) { + if (!::android::fs_mgr::ReadDefaultFstab(&fstab)) { + return VOL_FSTAB; + } + const ::android::fs_mgr::FstabEntry *v = ::android::fs_mgr::GetEntryForPath(&fstab, volume); + if (v == nullptr) { + return VOL_UNKNOWN; + } + if (::android::fs_mgr::EnsurePathUnmounted(&fstab, volume) != true) { + return VOL_MOUNTED; + } + + int fd = open(v->blk_device.c_str(), O_WRONLY | O_CREAT, 0644); + if (fd == -1) { + return VOL_BLK_DEV_OPEN; + } + wipe_block_device(fd, get_block_device_size(fd)); + close(fd); + + return WIPE_OK; +} + +// Attempt to reuse a WipeKeys function that might be found in the recovery +// library in order to clear any digital car keys on the secure element. +bool WipeDigitalCarKeys(void) { + static constexpr const char *kDefaultLibRecoveryUIExt = "librecovery_ui_ext.so"; + void *librecovery_ui_ext = dlopen(kDefaultLibRecoveryUIExt, RTLD_NOW); + if (librecovery_ui_ext == nullptr) { + // Dynamic library not found. Returning true since this likely + // means target does not support DCK. + return true; + } + + bool *(*WipeKeysFunc)(void *const); + reinterpret_cast<void *&>(WipeKeysFunc) = dlsym(librecovery_ui_ext, "WipeKeys"); + if (WipeKeysFunc == nullptr) { + // No WipeKeys implementation found. Returning true since this likely + // means target does not support DCK. + return true; + } + + return (*WipeKeysFunc)(nullptr); +} + +ScopedAStatus Fastboot::doOemSpecificErase() { + // Erase metadata partition along with userdata partition. + // Keep erasing Titan M even if failing on this case. + auto wipe_status = wipe_volume("/metadata"); + + bool dck_wipe_success = WipeDigitalCarKeys(); + + // Connect to Titan M + ::nos::NuggetClient client; + client.Open(); + if (!client.IsOpen()) { + return ScopedAStatus::fromServiceSpecificErrorWithMessage(BnFastboot::FAILURE_UNKNOWN, + "open Titan M fail"); + } + + // Tell Titan M to wipe user data + const uint32_t magicValue = htole32(ERASE_CONFIRMATION); + std::vector<uint8_t> magic(sizeof(magicValue)); + memcpy(magic.data(), &magicValue, sizeof(magicValue)); + const uint8_t retry_count = 5; + uint32_t nugget_status; + for (uint8_t i = 0; i < retry_count; i++) { + nugget_status = client.CallApp(APP_ID_NUGGET, NUGGET_PARAM_NUKE_FROM_ORBIT, magic, nullptr); + if (nugget_status == APP_SUCCESS && wipe_status == WIPE_OK) { + return ScopedAStatus::ok(); + } + } + + // Return exactly what happened + if (nugget_status != APP_SUCCESS && wipe_status != WIPE_OK && !dck_wipe_success) { + return ScopedAStatus::fromServiceSpecificErrorWithMessage( + BnFastboot::FAILURE_UNKNOWN, "Fail on wiping metadata, Titan M user data, and DCK"); + } else if (nugget_status != APP_SUCCESS && wipe_status != WIPE_OK) { + return ScopedAStatus::fromServiceSpecificErrorWithMessage( + BnFastboot::FAILURE_UNKNOWN, "Fail on wiping metadata and Titan M user data"); + } else if (nugget_status != APP_SUCCESS && !dck_wipe_success) { + return ScopedAStatus::fromServiceSpecificErrorWithMessage( + BnFastboot::FAILURE_UNKNOWN, "Titan M user data and DCK wipe failed"); + } else if (nugget_status != APP_SUCCESS) { + return ScopedAStatus::fromServiceSpecificErrorWithMessage(BnFastboot::FAILURE_UNKNOWN, + "Titan M user data wipe failed"); + } else if (wipe_status != WIPE_OK && !dck_wipe_success) { + return ScopedAStatus::fromServiceSpecificErrorWithMessage( + BnFastboot::FAILURE_UNKNOWN, "Fail on wiping metadata and DCK"); + } else if (!dck_wipe_success) { + return ScopedAStatus::fromServiceSpecificErrorWithMessage(BnFastboot::FAILURE_UNKNOWN, + "DCK wipe failed"); + } else { + if (wipe_vol_ret_msg.find(wipe_status) != wipe_vol_ret_msg.end()) + return ScopedAStatus::fromServiceSpecificErrorWithMessage( + BnFastboot::FAILURE_UNKNOWN, wipe_vol_ret_msg[wipe_status].c_str()); + else // Should not reach here, but handle it anyway + return ScopedAStatus::fromServiceSpecificErrorWithMessage(BnFastboot::FAILURE_UNKNOWN, + "Unknown failure"); + } + + // Return exactly what happened + if (nugget_status != APP_SUCCESS && wipe_status != WIPE_OK) { + return ScopedAStatus::fromServiceSpecificErrorWithMessage( + BnFastboot::FAILURE_UNKNOWN, "Fail on wiping metadata and Titan M user data"); + + } else if (nugget_status != APP_SUCCESS) { + return ScopedAStatus::fromServiceSpecificErrorWithMessage(BnFastboot::FAILURE_UNKNOWN, + "Titan M user data wipe failed"); + } else { + if (wipe_vol_ret_msg.find(wipe_status) != wipe_vol_ret_msg.end()) + return ScopedAStatus::fromServiceSpecificErrorWithMessage( + BnFastboot::FAILURE_UNKNOWN, wipe_vol_ret_msg[wipe_status].c_str()); + else // Should not reach here, but handle it anyway + return ScopedAStatus::fromServiceSpecificErrorWithMessage(BnFastboot::FAILURE_UNKNOWN, + "Unknown failure"); + } + + return ScopedAStatus::ok(); +} + +} // namespace fastboot +} // namespace hardware +} // namespace android +} // namespace aidl diff --git a/fastboot/android.hardware.fastboot-service.pixel.xml b/fastboot/android.hardware.fastboot-service.pixel.xml new file mode 100644 index 00000000..9490f98e --- /dev/null +++ b/fastboot/android.hardware.fastboot-service.pixel.xml @@ -0,0 +1,8 @@ +<manifest version="1.0" type="device"> + <hal format="aidl"> + <name>android.hardware.fastboot</name> + <version>1</version> + <fqname>IFastboot/default</fqname> + </hal> +</manifest> + diff --git a/fastboot/android.hardware.fastboot-service.pixel_recovery.rc b/fastboot/android.hardware.fastboot-service.pixel_recovery.rc new file mode 100644 index 00000000..799b716b --- /dev/null +++ b/fastboot/android.hardware.fastboot-service.pixel_recovery.rc @@ -0,0 +1,6 @@ +service vendor.pixel-fastboot /system/bin/hw/android.hardware.fastboot-service.pixel_recovery + class hal + seclabel u:r:hal_fastboot_default:s0 + user root + group root + interface aidl android.hardware.fastboot.IFastboot/default diff --git a/fastboot/include/fastboot/Fastboot_aidl.h b/fastboot/include/fastboot/Fastboot_aidl.h new file mode 100644 index 00000000..51ae7380 --- /dev/null +++ b/fastboot/include/fastboot/Fastboot_aidl.h @@ -0,0 +1,41 @@ +/* + * Copyright (C) 2022 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. + */ + +#pragma once + +#include "aidl/android/hardware/fastboot/BnFastboot.h" + +namespace aidl { +namespace android { +namespace hardware { +namespace fastboot { +class Fastboot : public BnFastboot { +#define FB_OEM_SET_BRIGHTNESS "setbrightness" + ::ndk::ScopedAStatus doOemCommand(const std::string &in_oemCmd, + std::string *_aidl_return) override; + ::ndk::ScopedAStatus doOemSpecificErase() override; + ::ndk::ScopedAStatus getBatteryVoltageFlashingThreshold(int32_t *_aidl_return) override; + ::ndk::ScopedAStatus getOffModeChargeState(bool *_aidl_return) override; + ::ndk::ScopedAStatus getPartitionType( + const std::string &in_partitionName, + ::aidl::android::hardware::fastboot::FileSystemType *_aidl_return) override; + ::ndk::ScopedAStatus getVariant(std::string *_aidl_return) override; +}; + +} // namespace fastboot +} // namespace hardware +} // namespace android +} // namespace aidl diff --git a/fastboot/main.cpp b/fastboot/main.cpp new file mode 100644 index 00000000..d4c11179 --- /dev/null +++ b/fastboot/main.cpp @@ -0,0 +1,39 @@ + +/* + * Copyright (C) 2022 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. + */ + +#include <android-base/logging.h> +#include <android/binder_manager.h> +#include <android/binder_process.h> + +#include "include/fastboot/Fastboot_aidl.h" + +using aidl::android::hardware::fastboot::Fastboot; +using aidl::android::hardware::fastboot::IFastboot; + +int main(int, char *argv[]) { + android::base::InitLogging(argv, android::base::KernelLogger); + ABinderProcess_setThreadPoolMaxThreadCount(0); + std::shared_ptr<IFastboot> service = ndk::SharedRefBase::make<Fastboot>(); + + const std::string instance = std::string(IFastboot::descriptor) + "/default"; + auto status = AServiceManager_addService(service->asBinder().get(), instance.c_str()); + CHECK_EQ(status, STATUS_OK) << "Failed to add service " << instance << " " << status; + LOG(INFO) << "IFastboot AIDL service running..."; + + ABinderProcess_joinThreadPool(); + return EXIT_FAILURE; // should not reach +} diff --git a/health/Android.bp b/health/Android.bp index 136e7dbd..3039431d 100644 --- a/health/Android.bp +++ b/health/Android.bp @@ -35,20 +35,19 @@ cc_library { export_shared_lib_headers: [ "android.frameworks.stats-V1-ndk", - "android.hardware.health-V1-ndk", - "pixelatoms-cpp", + "android.hardware.health-V2-ndk", + "libpixelatoms_defs", ], shared_libs: [ "android.frameworks.stats-V1-ndk", - "android.hardware.health-V1-ndk", + "android.hardware.health-V2-ndk", "libbase", "libbinder_ndk", "libcutils", "libhidlbase", - "libprotobuf-cpp-lite", + "libpixelatoms_defs", "libutils", - "pixelatoms-cpp", ], } diff --git a/health/BatteryDefender.cpp b/health/BatteryDefender.cpp index 8b693f0e..66876a50 100644 --- a/health/BatteryDefender.cpp +++ b/health/BatteryDefender.cpp @@ -239,6 +239,10 @@ bool BatteryDefender::isBatteryDefenderDisabled(const int vendorStart, const int return isOverrideDisabled || (isDefaultVendorChargeLevel == false) || (isCtrlEnabled == false); } +bool BatteryDefender::isDockDefendTrigger(void) { + return readFileToInt(kPathDockState, true) == 1; +} + void BatteryDefender::addTimeToChargeTimers(void) { if (mIsPowerAvailable) { if (mHasReachedHighCapacityLevel) { @@ -410,6 +414,11 @@ void BatteryDefender::updateDefenderProperties( health_info->batteryHealth = BatteryHealth::OVERHEAT; } + /* Do the same as above when dock-defend triggers */ + if (mIsDockDefendTrigger) { + health_info->batteryHealth = BatteryHealth::OVERHEAT; + } + /** * If the kernel is forcing the input current limit to 0, then the online status may * need to be overwritten. Also, setting a charge limit below the current charge level @@ -461,6 +470,7 @@ void BatteryDefender::update(HealthInfo *health_info) { mIsDefenderDisabled = isBatteryDefenderDisabled(chargeLevelVendorStart, chargeLevelVendorStop); mIsPowerAvailable = isChargePowerAvailable(); mTimeBetweenUpdateCalls = getDeltaTimeSeconds(&mTimePreviousSecs); + mIsDockDefendTrigger = isDockDefendTrigger(); // Run state machine stateMachine_runAction(mCurrentState, *health_info); diff --git a/health/BatteryMetricsLogger.cpp b/health/BatteryMetricsLogger.cpp index 5e4c7fb9..7f6adb39 100644 --- a/health/BatteryMetricsLogger.cpp +++ b/health/BatteryMetricsLogger.cpp @@ -19,17 +19,13 @@ #include <pixelhealth/HealthHelper.h> #include <pixelhealth/StatsHelper.h> -using aidl::android::hardware::health::BatteryStatus; -using aidl::android::hardware::health::HealthInfo; - namespace hardware { namespace google { namespace pixel { namespace health { -VendorBatteryHealthSnapshot::BatterySnapshotType toBatterySnapshotType(int type) { - return static_cast<VendorBatteryHealthSnapshot::BatterySnapshotType>(type); -} +using aidl::android::hardware::health::BatteryStatus; +using aidl::android::hardware::health::HealthInfo; BatteryMetricsLogger::BatteryMetricsLogger(const char *const batt_res, const char *const batt_ocv, const char *const batt_avg_res, int sample_period, @@ -57,26 +53,12 @@ bool BatteryMetricsLogger::uploadOutlierMetric(const std::shared_ptr<IStats> &st if (kStatsSnapshotType[type] < 0) return false; - VendorBatteryHealthSnapshot min_stats_ss; - min_stats_ss.set_type(toBatterySnapshotType(kStatsSnapshotType[type])); - min_stats_ss.set_temperature_deci_celsius(min_[type][TEMP]); - min_stats_ss.set_voltage_micro_volt(min_[type][VOLT]); - min_stats_ss.set_current_micro_amps(min_[type][CURR]); - min_stats_ss.set_open_circuit_micro_volt(min_[type][OCV]); - min_stats_ss.set_resistance_micro_ohm(min_[type][RES]); - min_stats_ss.set_level_percent(min_[type][SOC]); - - VendorBatteryHealthSnapshot max_stats_ss; - max_stats_ss.set_type(toBatterySnapshotType(kStatsSnapshotType[type] + 1)); - max_stats_ss.set_temperature_deci_celsius(max_[type][TEMP]); - max_stats_ss.set_voltage_micro_volt(max_[type][VOLT]); - max_stats_ss.set_current_micro_amps(max_[type][CURR]); - max_stats_ss.set_open_circuit_micro_volt(max_[type][OCV]); - max_stats_ss.set_resistance_micro_ohm(max_[type][RES]); - max_stats_ss.set_level_percent(max_[type][SOC]); - - reportBatteryHealthSnapshot(stats_client, min_stats_ss); - reportBatteryHealthSnapshot(stats_client, max_stats_ss); + reportBatteryHealthSnapshot(stats_client, kStatsSnapshotType[type], min_[type][TEMP], + min_[type][VOLT], min_[type][CURR], min_[type][OCV], + min_[type][RES], min_[type][SOC]); + reportBatteryHealthSnapshot(stats_client, kStatsSnapshotType[type] + 1, max_[type][TEMP], + max_[type][VOLT], max_[type][CURR], max_[type][OCV], + max_[type][RES], max_[type][SOC]); return true; } @@ -101,16 +83,9 @@ bool BatteryMetricsLogger::uploadAverageBatteryResistance( return false; } // Upload average metric - VendorBatteryHealthSnapshot avg_res_ss_stats; - avg_res_ss_stats.set_type(VendorBatteryHealthSnapshot::BATTERY_SNAPSHOT_TYPE_AVG_RESISTANCE); - avg_res_ss_stats.set_temperature_deci_celsius(0); - avg_res_ss_stats.set_voltage_micro_volt(0); - avg_res_ss_stats.set_current_micro_amps(0); - avg_res_ss_stats.set_open_circuit_micro_volt(0); - avg_res_ss_stats.set_resistance_micro_ohm(batt_avg_res); - avg_res_ss_stats.set_level_percent(0); - - reportBatteryHealthSnapshot(stats_client, avg_res_ss_stats); + reportBatteryHealthSnapshot(stats_client, + VendorBatteryHealthSnapshot::BATTERY_SNAPSHOT_TYPE_AVG_RESISTANCE, + 0, 0, 0, 0, batt_avg_res, 0); return true; } diff --git a/health/LowBatteryShutdownMetrics.cpp b/health/LowBatteryShutdownMetrics.cpp index 3ff606c9..b3d43f8b 100644 --- a/health/LowBatteryShutdownMetrics.cpp +++ b/health/LowBatteryShutdownMetrics.cpp @@ -52,7 +52,6 @@ bool LowBatteryShutdownMetrics::uploadVoltageAvg(void) { } // Process and upload comma-delimited last voltage values - VendorBatteryCausedShutdown shutdown; int32_t voltage_avg; for (const auto &item : android::base::Split(prop_contents, ",")) { if (!(voltage_avg = stoi(item))) { @@ -60,8 +59,7 @@ bool LowBatteryShutdownMetrics::uploadVoltageAvg(void) { continue; } LOG(INFO) << "Uploading voltage_avg: " << std::to_string(voltage_avg); - shutdown.set_last_recorded_micro_volt(voltage_avg); - reportBatteryCausedShutdown(stats_client, shutdown); + reportBatteryCausedShutdown(stats_client, voltage_avg); } // Clear property now that we've uploaded its contents diff --git a/health/StatsHelper.cpp b/health/StatsHelper.cpp index 22fb9f3e..4900e4f0 100644 --- a/health/StatsHelper.cpp +++ b/health/StatsHelper.cpp @@ -18,6 +18,8 @@ #include <android/binder_manager.h> #include <pixelhealth/StatsHelper.h> +#include "pixelatoms_defs.h" + #define LOG_TAG "pixelhealth-vendor" #include <utils/Log.h> @@ -29,7 +31,8 @@ namespace health { using aidl::android::frameworks::stats::VendorAtom; using aidl::android::frameworks::stats::VendorAtomValue; -namespace PixelAtoms = android::hardware::google::pixel::PixelAtoms; + +namespace PixelAtoms = hardware::google::pixel::PixelAtoms; std::shared_ptr<IStats> getStatsService() { const std::string instance = std::string() + IStats::descriptor + "/default"; @@ -48,29 +51,30 @@ std::shared_ptr<IStats> getStatsService() { return IStats::fromBinder(ndk::SpAIBinder(AServiceManager_getService(instance.c_str()))); } -void reportBatteryHealthSnapshot(const std::shared_ptr<IStats> &stats_client, - const VendorBatteryHealthSnapshot &batteryHealthSnapshot) { +void reportBatteryHealthSnapshot(const std::shared_ptr<IStats> &stats_client, int32_t type, + int32_t temperature_deci_celsius, int32_t voltage_micro_volt, + int32_t current_micro_amps, int32_t open_circuit_micro_volt, + int32_t resistance_micro_ohm, int32_t level_percent) { // Load values array std::vector<VendorAtomValue> values(7); VendorAtomValue tmp; - tmp.set<VendorAtomValue::intValue>(batteryHealthSnapshot.type()); + tmp.set<VendorAtomValue::intValue>(type); values[0] = tmp; - tmp.set<VendorAtomValue::intValue>(batteryHealthSnapshot.temperature_deci_celsius()); + tmp.set<VendorAtomValue::intValue>(temperature_deci_celsius); values[1] = tmp; - tmp.set<VendorAtomValue::intValue>(batteryHealthSnapshot.voltage_micro_volt()); + tmp.set<VendorAtomValue::intValue>(voltage_micro_volt); values[2] = tmp; - tmp.set<VendorAtomValue::intValue>(batteryHealthSnapshot.current_micro_amps()); + tmp.set<VendorAtomValue::intValue>(current_micro_amps); values[3] = tmp; - tmp.set<VendorAtomValue::intValue>(batteryHealthSnapshot.open_circuit_micro_volt()); + tmp.set<VendorAtomValue::intValue>(open_circuit_micro_volt); values[4] = tmp; - tmp.set<VendorAtomValue::intValue>(batteryHealthSnapshot.resistance_micro_ohm()); + tmp.set<VendorAtomValue::intValue>(resistance_micro_ohm); values[5] = tmp; - tmp.set<VendorAtomValue::intValue>(batteryHealthSnapshot.level_percent()); + tmp.set<VendorAtomValue::intValue>(level_percent); values[6] = tmp; // Send vendor atom to IStats HAL - VendorAtom event = {.reverseDomainName = "", - .atomId = PixelAtoms::Atom::kVendorBatteryHealthSnapshot, + VendorAtom event = {.atomId = PixelAtoms::VENDOR_BATTERY_HEALTH_SNAPSHOT, .values = std::move(values)}; const ndk::ScopedAStatus ret = stats_client->reportVendorAtom(event); if (!ret.isOk()) @@ -78,16 +82,15 @@ void reportBatteryHealthSnapshot(const std::shared_ptr<IStats> &stats_client, } void reportBatteryCausedShutdown(const std::shared_ptr<IStats> &stats_client, - const VendorBatteryCausedShutdown &batteryCausedShutdown) { + int32_t last_recorded_micro_volt) { // Load values array std::vector<VendorAtomValue> values(1); VendorAtomValue tmp; - tmp.set<VendorAtomValue::intValue>(batteryCausedShutdown.last_recorded_micro_volt()); + tmp.set<VendorAtomValue::intValue>(last_recorded_micro_volt); values[0] = tmp; // Send vendor atom to IStats HAL - VendorAtom event = {.reverseDomainName = "", - .atomId = PixelAtoms::Atom::kVendorBatteryCausedShutdown, + VendorAtom event = {.atomId = PixelAtoms::VENDOR_BATTERY_CAUSED_SHUTDOWN, .values = std::move(values)}; const ndk::ScopedAStatus ret = stats_client->reportVendorAtom(event); if (!ret.isOk()) diff --git a/health/include/pixelhealth/BatteryDefender.h b/health/include/pixelhealth/BatteryDefender.h index 40d190bd..58dd0805 100644 --- a/health/include/pixelhealth/BatteryDefender.h +++ b/health/include/pixelhealth/BatteryDefender.h @@ -101,6 +101,7 @@ class BatteryDefender { "/mnt/vendor/persist/battery/defender_charger_time"; const std::string kPathPersistDefenderActiveTime = "/mnt/vendor/persist/battery/defender_active_time"; + const std::string kPathDockState = "/sys/devices/platform/google,charger/dd_state"; // Properties const char *const kPropChargeLevelVendorStart = "persist.vendor.charge.start.level"; @@ -140,6 +141,7 @@ class BatteryDefender { bool mIsDockPresent = false; bool mIsPowerAvailable = false; bool mIsDefenderDisabled = false; + bool mIsDockDefendTrigger = false; int32_t mTimeToActivateSecsModified; // State @@ -183,6 +185,7 @@ class BatteryDefender { bool isDefaultChargeLevel(const int start, const int stop); bool isBatteryDefenderDisabled(const int vendorStart, const int vendorStop); void addTimeToChargeTimers(void); + bool isDockDefendTrigger(void); }; } // namespace health diff --git a/health/include/pixelhealth/BatteryMetricsLogger.h b/health/include/pixelhealth/BatteryMetricsLogger.h index 9bf2a69a..e4d4d75c 100644 --- a/health/include/pixelhealth/BatteryMetricsLogger.h +++ b/health/include/pixelhealth/BatteryMetricsLogger.h @@ -23,20 +23,22 @@ #include <android-base/logging.h> #include <android-base/strings.h> #include <batteryservice/BatteryService.h> -#include <hardware/google/pixel/pixelstats/pixelatoms.pb.h> #include <math.h> #include <time.h> #include <utils/Timers.h> #include <string> +#include "pixelatoms_defs.h" + namespace hardware { namespace google { namespace pixel { namespace health { using aidl::android::frameworks::stats::IStats; -using android::hardware::google::pixel::PixelAtoms::VendorBatteryHealthSnapshot; + +using hardware::google::pixel::PixelAtoms::VendorBatteryHealthSnapshot; class BatteryMetricsLogger { public: diff --git a/health/include/pixelhealth/StatsHelper.h b/health/include/pixelhealth/StatsHelper.h index 90bf985f..ea49bee4 100644 --- a/health/include/pixelhealth/StatsHelper.h +++ b/health/include/pixelhealth/StatsHelper.h @@ -18,7 +18,6 @@ #define HARDWARE_GOOGLE_PIXEL_HEALTH_STATSHELPER_H #include <aidl/android/frameworks/stats/IStats.h> -#include <hardware/google/pixel/pixelstats/pixelatoms.pb.h> namespace hardware { namespace google { @@ -26,16 +25,16 @@ namespace pixel { namespace health { using aidl::android::frameworks::stats::IStats; -using android::hardware::google::pixel::PixelAtoms::VendorBatteryCausedShutdown; -using android::hardware::google::pixel::PixelAtoms::VendorBatteryHealthSnapshot; std::shared_ptr<IStats> getStatsService(); -void reportBatteryHealthSnapshot(const std::shared_ptr<IStats> &stats_client, - const VendorBatteryHealthSnapshot &batteryHealthSnapshot); +void reportBatteryHealthSnapshot(const std::shared_ptr<IStats> &stats_client, int32_t type, + int32_t temperature_deci_celsius, int32_t voltage_micro_volt, + int32_t current_micro_amps, int32_t open_circuit_micro_volt, + int32_t resistance_micro_ohm, int32_t level_percent); void reportBatteryCausedShutdown(const std::shared_ptr<IStats> &stats_client, - const VendorBatteryCausedShutdown &batteryCausedShutdown); + int32_t last_recorded_micro_volt); } // namespace health } // namespace pixel diff --git a/input/twoshay.mk b/input/twoshay.mk new file mode 100644 index 00000000..d976ab23 --- /dev/null +++ b/input/twoshay.mk @@ -0,0 +1,4 @@ +PRODUCT_SOONG_NAMESPACES += vendor/google/input/twoshay +BOARD_VENDOR_SEPOLICY_DIRS += hardware/google/pixel-sepolicy/input +PRODUCT_PACKAGES += twoshay + diff --git a/kernel_headers/Android.bp b/kernel_headers/Android.bp index 660a5924..e59f4aee 100644 --- a/kernel_headers/Android.bp +++ b/kernel_headers/Android.bp @@ -7,3 +7,9 @@ kernel_headers { vendor: true, recovery_available: true, } + +kernel_headers { + name: "qti_display_kernel_headers", + vendor: true, + recovery_available: true +} diff --git a/misc_writer/include/misc_writer/misc_writer.h b/misc_writer/include/misc_writer/misc_writer.h index 3c22c162..ce3da5c8 100644 --- a/misc_writer/include/misc_writer/misc_writer.h +++ b/misc_writer/include/misc_writer/misc_writer.h @@ -34,6 +34,12 @@ enum class MiscWriterActions : int32_t { kClearSotaFlag, kSetEnablePkvmFlag, kSetDisablePkvmFlag, + kSetWristOrientationFlag, + kClearWristOrientationFlag, + kWriteTimeFormat, + kWriteTimeOffset, + kSetMaxRamSize, + kClearMaxRamSize, kUnset = -1, }; @@ -47,6 +53,23 @@ class MiscWriter { static constexpr uint32_t kPkvmFlagOffsetInVendorSpace = 64; static constexpr char kEnablePkvmFlag[] = "enable-pkvm"; static constexpr char kDisablePkvmFlag[] = "disable-pkvm"; + static constexpr uint32_t kWristOrientationFlagOffsetInVendorSpace = 96; + static constexpr char kWristOrientationFlag[] = "wrist-orientation="; + static constexpr uint32_t kTimeFormatValOffsetInVendorSpace = 128; + static constexpr char kTimeFormat[] = "timeformat="; + static constexpr uint32_t kTimeOffsetValOffsetInVendorSpace = 160; + static constexpr char kTimeOffset[] = "timeoffset="; + static constexpr uint32_t kMaxRamSizeOffsetInVendorSpace = 192; + static constexpr char kMaxRamSize[] = "max-ram-size="; + + // Minimum and maximum valid value for max-ram-size + static constexpr int32_t kRamSizeDefault = -1; + static constexpr uint32_t kRamSizeMin = 2048; + static constexpr uint32_t kRamSizeMax = 65536; + + // Minimum and maximum time zone are -12 and 14 hours from GMT + static constexpr int32_t kMinTimeOffset = -12 * 60 * 60 * 1000; + static constexpr int32_t kMaxTimeOffset = 14 * 60 * 60 * 1000; // Returns true of |size| bytes data starting from |offset| is fully inside the vendor space. static bool OffsetAndSizeInVendorSpace(size_t offset, size_t size); @@ -56,6 +79,10 @@ class MiscWriter { std::string* err); explicit MiscWriter(const MiscWriterActions& action) : action_(action) {} + explicit MiscWriter(const MiscWriterActions &action, const char data) + : action_(action), chardata_(data) {} + explicit MiscWriter(const MiscWriterActions &action, std::string data) + : action_(action), stringdata_(data) {} // Performs the stored MiscWriterActions. If |override_offset| is set, writes to the input offset // in the vendor space of /misc instead of the default offset. @@ -63,6 +90,8 @@ class MiscWriter { private: MiscWriterActions action_{ MiscWriterActions::kUnset }; + char chardata_{'0'}; + std::string stringdata_; }; } // namespace pixel diff --git a/misc_writer/misc_writer.cpp b/misc_writer/misc_writer.cpp index 0d867c23..8458649f 100644 --- a/misc_writer/misc_writer.cpp +++ b/misc_writer/misc_writer.cpp @@ -70,6 +70,29 @@ bool MiscWriter::PerformAction(std::optional<size_t> override_offset) { content = (action_ == MiscWriterActions::kSetEnablePkvmFlag) ? kEnablePkvmFlag : kDisablePkvmFlag; break; + case MiscWriterActions::kSetWristOrientationFlag: + case MiscWriterActions::kClearWristOrientationFlag: + offset = override_offset.value_or(kWristOrientationFlagOffsetInVendorSpace); + content = (action_ == MiscWriterActions::kSetWristOrientationFlag) + ? std::string(kWristOrientationFlag) + chardata_ + : std::string(strlen(kWristOrientationFlag) + sizeof(chardata_), 0); + break; + case MiscWriterActions::kWriteTimeFormat: + offset = override_offset.value_or(kTimeFormatValOffsetInVendorSpace); + content = std::string(kTimeFormat) + chardata_; + break; + case MiscWriterActions::kWriteTimeOffset: + offset = override_offset.value_or(kTimeOffsetValOffsetInVendorSpace); + content = std::string(kTimeOffset) + stringdata_; + content.resize(strlen(kTimeOffset) + std::to_string(kMinTimeOffset).size(), 0); + break; + case MiscWriterActions::kSetMaxRamSize: + case MiscWriterActions::kClearMaxRamSize: + offset = override_offset.value_or(kMaxRamSizeOffsetInVendorSpace); + content = (action_ == MiscWriterActions::kSetMaxRamSize) + ? std::string(kMaxRamSize).append(stringdata_).append("\n") + : std::string(32, 0); + break; case MiscWriterActions::kUnset: LOG(ERROR) << "The misc writer action must be set"; return false; diff --git a/misc_writer/misc_writer_main.cpp b/misc_writer/misc_writer_main.cpp index 7c5e27ae..0af45a91 100644 --- a/misc_writer/misc_writer_main.cpp +++ b/misc_writer/misc_writer_main.cpp @@ -44,6 +44,12 @@ static int Usage(std::string_view name) { std::cerr << " --clear-sota Clear the silent OTA flag\n"; std::cerr << " --set-enable-pkvm Write the enable pKVM flag\n"; std::cerr << " --set-disable-pkvm Write the disable pKVM flag\n"; + std::cerr << " --set-wrist-orientation <0-3> Write the wrist orientation flag\n"; + std::cerr << " --clear-wrist-orientation Clear the wrist orientation flag\n"; + std::cerr << " --set-timeformat Write the time format value (1=24hr, 0=12hr)\n"; + std::cerr << " --set-timeoffset Write the time offset value (tz_time - utc_time)\n"; + std::cerr << " --set-max-ram-size <2048-65536> Write the sw limit max ram size in MB\n"; + std::cerr << " --set-max-ram-size <-1> Clear the sw limit max ram size\n"; std::cerr << "Writes the given hex string to the specified offset in vendor space in /misc " "partition.\nDefault offset is used for each action unless " "--override-vendor-space-offset is specified.\n"; @@ -57,9 +63,14 @@ int main(int argc, char** argv) { { "clear-dark-theme", no_argument, nullptr, 0 }, { "set-sota", no_argument, nullptr, 0 }, { "clear-sota", no_argument, nullptr, 0 }, + { "set-wrist-orientation", required_argument, nullptr, 0 }, + { "clear-wrist-orientation", no_argument, nullptr, 0 }, { "override-vendor-space-offset", required_argument, nullptr, 0 }, { "set-enable-pkvm", no_argument, nullptr, 0 }, { "set-disable-pkvm", no_argument, nullptr, 0 }, + { "set-timeformat", required_argument, nullptr, 0}, + { "set-timeoffset", required_argument, nullptr, 0}, + { "set-max-ram-size", required_argument, nullptr, 0}, { nullptr, 0, nullptr, 0 }, }; @@ -70,6 +81,7 @@ int main(int argc, char** argv) { { "clear-sota", MiscWriterActions::kClearSotaFlag }, { "set-enable-pkvm", MiscWriterActions::kSetEnablePkvmFlag }, { "set-disable-pkvm", MiscWriterActions::kSetDisablePkvmFlag }, + { "clear-wrist-orientation", MiscWriterActions::kClearWristOrientationFlag }, }; std::unique_ptr<MiscWriter> misc_writer; @@ -91,6 +103,76 @@ int main(int argc, char** argv) { return Usage(argv[0]); } override_offset = offset; + } else if (option_name == "set-wrist-orientation"s) { + int orientation; + if (!android::base::ParseInt(optarg, &orientation)) { + LOG(ERROR) << "Failed to parse the orientation: " << optarg; + return Usage(argv[0]); + } + if (orientation < 0 || orientation > 3) { + LOG(ERROR) << "Orientation out of range: " << optarg; + return Usage(argv[0]); + } + if (misc_writer) { + LOG(ERROR) << "Misc writer action has already been set"; + return Usage(argv[0]); + } + misc_writer = std::make_unique<MiscWriter>(MiscWriterActions::kSetWristOrientationFlag, + '0' + orientation); + } else if (option_name == "set-timeformat"s) { + int timeformat; + if (!android::base::ParseInt(optarg, &timeformat)) { + LOG(ERROR) << "Failed to parse the timeformat: " << optarg; + return Usage(argv[0]); + } + if (timeformat < 0 || timeformat > 1) { + LOG(ERROR) << "Time format out of range: " << optarg; + return Usage(argv[0]); + } + if (misc_writer) { + LOG(ERROR) << "Misc writer action has already been set"; + return Usage(argv[0]); + } + misc_writer = std::make_unique<MiscWriter>(MiscWriterActions::kWriteTimeFormat, + '0' + timeformat); + } else if (option_name == "set-timeoffset"s) { + int timeoffset; + if (!android::base::ParseInt(optarg, &timeoffset)) { + LOG(ERROR) << "Failed to parse the timeoffset: " << optarg; + return Usage(argv[0]); + } + if (timeoffset < MiscWriter::kMinTimeOffset || timeoffset > MiscWriter::kMaxTimeOffset) { + LOG(ERROR) << "Time offset out of range: " << optarg; + return Usage(argv[0]); + } + if (misc_writer) { + LOG(ERROR) << "Misc writer action has already been set"; + return Usage(argv[0]); + } + misc_writer = std::make_unique<MiscWriter>(MiscWriterActions::kWriteTimeOffset, + std::to_string(timeoffset)); + } else if (option_name == "set-max-ram-size"s) { + int max_ram_size; + if (!android::base::ParseInt(optarg, &max_ram_size)) { + LOG(ERROR) << "Failed to parse the max_ram_size: " << optarg; + return Usage(argv[0]); + } + if (max_ram_size != MiscWriter::kRamSizeDefault && + (max_ram_size < MiscWriter::kRamSizeMin || max_ram_size > MiscWriter::kRamSizeMax)) { + LOG(ERROR) << "max_ram_size out of range: " << optarg; + return Usage(argv[0]); + } + if (misc_writer) { + LOG(ERROR) << "Misc writer action has already been set"; + return Usage(argv[0]); + } + + if (max_ram_size == MiscWriter::kRamSizeDefault) { + misc_writer = std::make_unique<MiscWriter>(MiscWriterActions::kClearMaxRamSize); + } else { + misc_writer = std::make_unique<MiscWriter>(MiscWriterActions::kSetMaxRamSize, + std::to_string(max_ram_size)); + } } else if (auto iter = action_map.find(option_name); iter != action_map.end()) { if (misc_writer) { LOG(ERROR) << "Misc writer action has already been set"; diff --git a/misc_writer/misc_writer_test.cpp b/misc_writer/misc_writer_test.cpp index e8b207af..651f6409 100644 --- a/misc_writer/misc_writer_test.cpp +++ b/misc_writer/misc_writer_test.cpp @@ -106,6 +106,19 @@ TEST_F(MiscWriterTest, SetClearSota) { CheckMiscPartitionVendorSpaceContent(32, zeros); } +TEST_F(MiscWriterTest, SetMaxRamSize) { + misc_writer_ = std::make_unique<MiscWriter>(MiscWriterActions::kSetMaxRamSize, "8192"); + size_t offset = MiscWriter::kMaxRamSizeOffsetInVendorSpace; + ASSERT_TRUE(misc_writer_->PerformAction(offset)); + std::string expected = std::string(MiscWriter::kMaxRamSize) + "8192"; + CheckMiscPartitionVendorSpaceContent(offset, expected); + + misc_writer_ = std::make_unique<MiscWriter>(MiscWriterActions::kClearMaxRamSize); + ASSERT_TRUE(misc_writer_->PerformAction(offset)); + std::string zeros(expected.size(), 0); + CheckMiscPartitionVendorSpaceContent(offset, zeros); +} + TEST_F(MiscWriterTest, WriteMiscPartitionVendorSpace) { std::string kTestMessage = "kTestMessage"; std::string err; diff --git a/mm/device_gki.mk b/mm/device_gki.mk index cd4fdf81..eac30a78 100644 --- a/mm/device_gki.mk +++ b/mm/device_gki.mk @@ -1,7 +1,15 @@ PRODUCT_COPY_FILES += \ hardware/google/pixel/mm/pixel-mm-gki.rc:$(TARGET_COPY_OUT_VENDOR)/etc/init/pixel-mm-gki.rc \ hardware/google/pixel/mm/fstab.zram.2g:$(TARGET_COPY_OUT_VENDOR)/etc/fstab.zram.2g \ - hardware/google/pixel/mm/fstab.zram.3g:$(TARGET_COPY_OUT_VENDOR)/etc/fstab.zram.3g + hardware/google/pixel/mm/fstab.zram.3g:$(TARGET_COPY_OUT_VENDOR)/etc/fstab.zram.3g \ + hardware/google/pixel/mm/fstab.zram.4g:$(TARGET_COPY_OUT_VENDOR)/etc/fstab.zram.4g \ + hardware/google/pixel/mm/fstab.zram.5g:$(TARGET_COPY_OUT_VENDOR)/etc/fstab.zram.5g \ + hardware/google/pixel/mm/fstab.zram.6g:$(TARGET_COPY_OUT_VENDOR)/etc/fstab.zram.6g \ + hardware/google/pixel/mm/fstab.zram.40p:$(TARGET_COPY_OUT_VENDOR)/etc/fstab.zram.40p \ + hardware/google/pixel/mm/fstab.zram.50p:$(TARGET_COPY_OUT_VENDOR)/etc/fstab.zram.50p \ + hardware/google/pixel/mm/fstab.zram.60p:$(TARGET_COPY_OUT_VENDOR)/etc/fstab.zram.60p \ + hardware/google/pixel/mm/fstab.zram.50p-1g:$(TARGET_COPY_OUT_VENDOR)/etc/fstab.zram.50p-1g \ + hardware/google/pixel/mm/fstab.zram.50p-2g:$(TARGET_COPY_OUT_VENDOR)/etc/fstab.zram.50p-2g ifneq (,$(filter userdebug eng, $(TARGET_BUILD_VARIANT))) PRODUCT_PACKAGES += \ diff --git a/mm/fstab.zram.2g b/mm/fstab.zram.2g index aa59346c..d1f94d4f 100644 --- a/mm/fstab.zram.2g +++ b/mm/fstab.zram.2g @@ -1 +1 @@ -/dev/block/zram0 none swap defaults zramsize=2147483648,max_comp_streams=8,zram_backingdev_size=512M +/dev/block/zram0 none swap defaults zramsize=2147483648,zram_backingdev_size=512M diff --git a/mm/fstab.zram.3g b/mm/fstab.zram.3g index b087adf1..2c45bcc6 100644 --- a/mm/fstab.zram.3g +++ b/mm/fstab.zram.3g @@ -1 +1 @@ -/dev/block/zram0 none swap defaults zramsize=3221225472,max_comp_streams=8,zram_backingdev_size=512M +/dev/block/zram0 none swap defaults zramsize=3221225472,zram_backingdev_size=512M diff --git a/mm/fstab.zram.40p b/mm/fstab.zram.40p new file mode 100644 index 00000000..5be8da4b --- /dev/null +++ b/mm/fstab.zram.40p @@ -0,0 +1 @@ +/dev/block/zram0 none swap defaults zramsize=40%,zram_backingdev_size=512M diff --git a/mm/fstab.zram.4g b/mm/fstab.zram.4g new file mode 100644 index 00000000..68a274d0 --- /dev/null +++ b/mm/fstab.zram.4g @@ -0,0 +1 @@ +/dev/block/zram0 none swap defaults zramsize=4294967296,zram_backingdev_size=512M diff --git a/mm/fstab.zram.50p b/mm/fstab.zram.50p new file mode 100644 index 00000000..7a845e55 --- /dev/null +++ b/mm/fstab.zram.50p @@ -0,0 +1 @@ +/dev/block/zram0 none swap defaults zramsize=50%,zram_backingdev_size=512M diff --git a/mm/fstab.zram.50p-1g b/mm/fstab.zram.50p-1g new file mode 100644 index 00000000..6f54d6f4 --- /dev/null +++ b/mm/fstab.zram.50p-1g @@ -0,0 +1 @@ +/dev/block/zram0 none swap defaults zramsize=50%,zram_backingdev_size=1G diff --git a/mm/fstab.zram.50p-2g b/mm/fstab.zram.50p-2g new file mode 100644 index 00000000..592ece91 --- /dev/null +++ b/mm/fstab.zram.50p-2g @@ -0,0 +1 @@ +/dev/block/zram0 none swap defaults zramsize=50%,zram_backingdev_size=2G diff --git a/mm/fstab.zram.5g b/mm/fstab.zram.5g new file mode 100644 index 00000000..d155a40d --- /dev/null +++ b/mm/fstab.zram.5g @@ -0,0 +1 @@ +/dev/block/zram0 none swap defaults zramsize=5368709120,zram_backingdev_size=512M diff --git a/mm/fstab.zram.60p b/mm/fstab.zram.60p new file mode 100644 index 00000000..ea62cdad --- /dev/null +++ b/mm/fstab.zram.60p @@ -0,0 +1 @@ +/dev/block/zram0 none swap defaults zramsize=60%,zram_backingdev_size=512M diff --git a/mm/fstab.zram.6g b/mm/fstab.zram.6g new file mode 100644 index 00000000..7e000c9c --- /dev/null +++ b/mm/fstab.zram.6g @@ -0,0 +1 @@ +/dev/block/zram0 none swap defaults zramsize=6442450944,zram_backingdev_size=512M diff --git a/mm/pixel-mm-gki.rc b/mm/pixel-mm-gki.rc index e5ab7f75..52603d5b 100644 --- a/mm/pixel-mm-gki.rc +++ b/mm/pixel-mm-gki.rc @@ -19,11 +19,61 @@ on init # khugepaged tuning write /sys/kernel/mm/transparent_hugepage/khugepaged/scan_sleep_millisecs 60000 -on property:persist.vendor.zram.size=* - setprop vendor.zram.size ${persist.vendor.zram.size} +# Property from experiments - server config +on property:persist.device_config.vendor_system_native_boot.zram_size=* + setprop vendor.zram.size ${persist.device_config.vendor_system_native_boot.zram_size} + +# Property for local test. It can overwrite the server side config +on property:sys.boot_completed=1 && property:persist.vendor.boot.zram.size=* + setprop vendor.zram.size ${persist.vendor.boot.zram.size} on property:sys.boot_completed=1 swapon_all /vendor/etc/fstab.zram.${vendor.zram.size} on property:sys.boot_completed=1 chmod 444 /sys/kernel/debug/page_owner + + # Create mm_event trace point. + # For legacy devices, only mm_event is using this trace instance. + # Debugfs is only used in legacy devices and going to be deprecated. + # If others want to put more,it should get hard review from pixel-perf-team. + mkdir /sys/kernel/tracing/instances/pixel 0755 system system + chown system system /sys/kernel/tracing/instances/pixel/trace + chmod 0660 /sys/kernel/tracing/instances/pixel/trace + chown system system /sys/kernel/tracing/instances/pixel/tracing_on + chmod 0660 /sys/kernel/tracing/instances/pixel/tracing_on + write /sys/kernel/tracing/instances/pixel/buffer_size_kb 64 + write /sys/kernel/tracing/instances/pixel/events/cma/cma_alloc_busy_retry/enable 1 + write /sys/kernel/tracing/instances/pixel/events/cma/cma_alloc_start/enable 1 + write /sys/kernel/tracing/instances/pixel/events/cma/cma_alloc_info/enable 1 + write /sys/kernel/tracing/instances/pixel/events/cma/cma_release/enable 1 + write /sys/kernel/tracing/instances/pixel/events/chunk_heap/enable 1 + write /sys/kernel/tracing/instances/pixel/events/dmabuf_heap/dma_buf_release/enable 1 + write /sys/kernel/tracing/instances/pixel/events/trusty/trusty_dma_buf_put/enable 1 + +# turns off tracing right before bugreporting to keep more traces +on property:init.svc.dumpstatez=running + write /sys/kernel/tracing/instances/pixel/tracing_on 0 + +on property:init.svc.dumpstatez=stopped + write /sys/kernel/tracing/instances/pixel/tracing_on 1 + +on property:init.svc.bugreport=running + write /sys/kernel/tracing/instances/pixel/tracing_on 0 + +on property:init.svc.bugreport=stopped + write /sys/kernel/tracing/instances/pixel/tracing_on 1 + +on property:init.svc.bugreportd=running + write /sys/kernel/tracing/instances/pixel/tracing_on 0 + +on property:init.svc.bugreportd=stopped + write /sys/kernel/tracing/instances/pixel/tracing_on 1 + +# max-ram-size experiment +service vendor.set_max_ram_size /vendor/bin/misc_writer --set-max-ram-size ${persist.device_config.vendor_system_native_boot.max_ram_size:--1} + disabled + oneshot + +on property:persist.device_config.vendor_system_native_boot.max_ram_size=* + start vendor.set_max_ram_size diff --git a/perfstatsd/io_usage.cpp b/perfstatsd/io_usage.cpp index a325bef9..66c4a46d 100644 --- a/perfstatsd/io_usage.cpp +++ b/perfstatsd/io_usage.cpp @@ -112,8 +112,6 @@ void ProcPidIoStats::update(bool forceAll) { // update mUidNameMapping only for new pids for (int i = 0, len = newpids.size(); i < len; i++) { uint32_t pid = newpids[i]; - if (sOptDebug > 1) - LOG(INFO) << i << "."; std::string buffer; if (!android::base::ReadFileToString("/proc/" + std::to_string(pid) + "/status", &buffer)) { if (sOptDebug) @@ -153,9 +151,6 @@ void ProcPidIoStats::update(bool forceAll) { while (buffer[e] && !std::isspace(buffer[e])) e++; std::string strUid(buffer, s, e - s); - if (sOptDebug > 1) - LOG(INFO) << "(pid, name, uid)=(" << pid << ", " << pname << ", " << strUid << ")" - << std::endl; uint32_t uid = (uint32_t)std::stoi(strUid); mUidNameMapping[uid] = pname; } diff --git a/pixelstats/Android.bp b/pixelstats/Android.bp index f99e8e86..949a86d9 100644 --- a/pixelstats/Android.bp +++ b/pixelstats/Android.bp @@ -23,9 +23,15 @@ cc_library { proto: { type: "lite", export_proto_headers: true, + include_dirs: [ + "external/protobuf/src", + "frameworks/proto_logging/stats", + ], }, srcs: [ "pixelatoms.proto", + ":libstats_atom_options_protos", + ":libprotobuf-internal-descriptor-proto", ], } @@ -34,9 +40,15 @@ java_library { vendor: true, proto: { type: "lite", + include_dirs: [ + "external/protobuf/src", + "frameworks/proto_logging/stats", + ], }, srcs: [ "pixelatoms.proto", + ":libstats_atom_options_protos", + ":libprotobuf-internal-descriptor-proto", ], sdk_version: "current", } @@ -45,12 +57,33 @@ java_library_host { name: "pixelatoms-java_host", proto: { type: "full", + include_dirs: [ + "external/protobuf/src", + "frameworks/proto_logging/stats", + ], }, srcs: [ "pixelatoms.proto", + ":libstats_atom_options_protos", ], } +genrule { + name: "pixelatoms_defs.h", + tools: ["stats-log-api-gen"], + cmd: "$(location stats-log-api-gen) --header $(genDir)/pixelatoms_defs.h --namespace hardware,google,pixel,PixelAtoms --vendor-proto hardware/google/pixel/pixelstats/pixelatoms.proto", + out: [ + "pixelatoms_defs.h", + ], +} + +cc_library { + name: "libpixelatoms_defs", + vendor: true, + generated_headers: ["pixelatoms_defs.h"], + export_generated_headers: ["pixelatoms_defs.h"], +} + cc_library { name: "libpixelstats", vendor: true, @@ -58,23 +91,23 @@ cc_library { tidy_disabled_srcs: [ "MmMetricsReporter.cpp", // b/215238264 - "WlcReporter.cpp", // b/215238264 ], srcs: [ "BatteryCapacityReporter.cpp", "BatteryEEPROMReporter.cpp", "BatteryHealthReporter.cpp", + "BrownoutDetectedReporter.cpp", "ChargeStatsReporter.cpp", "DropDetect.cpp", "MmMetricsReporter.cpp", "MitigationStatsReporter.cpp", - "OrientationCollector.cpp", "PcaChargeStats.cpp", "StatsHelper.cpp", "SysfsCollector.cpp", + "ThermalStatsReporter.cpp", + "TempResidencyReporter.cpp", "UeventListener.cpp", "WirelessChargeStats.cpp", - "WlcReporter.cpp", ], cflags: [ "-Wall", diff --git a/pixelstats/BatteryHealthReporter.cpp b/pixelstats/BatteryHealthReporter.cpp index 41df779d..102b5fed 100644 --- a/pixelstats/BatteryHealthReporter.cpp +++ b/pixelstats/BatteryHealthReporter.cpp @@ -79,24 +79,28 @@ void BatteryHealthReporter::reportBatteryHealthStatusEvent( BatteryHealthStatus::kCurrentImpedanceFieldNumber, BatteryHealthStatus::kBatteryAgeFieldNumber, BatteryHealthStatus::kCycleCountFieldNumber, + BatteryHealthStatus::kBatteryDisconnectStatusFieldNumber, }; const int32_t vtier_fields_size = std::size(health_status_stats_fields); - static_assert(vtier_fields_size == 10, "Unexpected battery health status fields size"); + static_assert(vtier_fields_size == 11, "Unexpected battery health status fields size"); std::vector<VendorAtomValue> values(vtier_fields_size); VendorAtomValue val; - int32_t i = 0, tmp[vtier_fields_size] = {0}; + int32_t i = 0, fields_size = 0, tmp[vtier_fields_size] = {0}; // health_algo: health_status, health_index,healh_capacity_index,health_imp_index, - // swelling_cumulative,health_full_capacity,current_impedance, battery_age,cycle_count - if (sscanf(line, "%d: %d, %d,%d,%d %d,%d,%d %d,%d", &tmp[0], &tmp[1], &tmp[2], &tmp[3], &tmp[4], - &tmp[5], &tmp[6], &tmp[7], &tmp[8], &tmp[9]) != vtier_fields_size) { - /* If format isn't as expected, then ignore line on purpose */ + // swelling_cumulative,health_full_capacity,current_impedance, battery_age,cycle_count, + // bpst_status + fields_size = sscanf(line, "%d: %d, %d,%d,%d %d,%d,%d %d,%d, %d", &tmp[0], &tmp[1], &tmp[2], + &tmp[3], &tmp[4], &tmp[5], &tmp[6], &tmp[7], &tmp[8], &tmp[9], &tmp[10]); + if (fields_size < (vtier_fields_size - 1) || fields_size > vtier_fields_size) { + // Whether bpst_status exists or not, it needs to be compatible + // If format isn't as expected, then ignore line on purpose return; } ALOGD("BatteryHealthStatus: processed %s", line); - for (i = 0; i < vtier_fields_size; i++) { + for (i = 0; i < fields_size; i++) { val.set<VendorAtomValue::intValue>(tmp[i]); values[health_status_stats_fields[i] - kVendorAtomOffset] = val; } diff --git a/pixelstats/BrownoutDetectedReporter.cpp b/pixelstats/BrownoutDetectedReporter.cpp new file mode 100644 index 00000000..58edc995 --- /dev/null +++ b/pixelstats/BrownoutDetectedReporter.cpp @@ -0,0 +1,318 @@ +/* + * Copyright (C) 2022 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: BrownoutDetected" + +#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/BrownoutDetectedReporter.h> +#include <time.h> +#include <utils/Log.h> + +#include <map> +#include <regex> + +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::BrownoutDetected; + +#define READING_IDX 2 +#define KEY_IDX 0 +#define DEFAULT_BATTERY_TEMP 9999999 +#define DEFAULT_BATTERY_SOC 100 +#define DEFAULT_BATTERY_VOLT 5000000 + +const std::regex kTimestampPattern("^\\S+\\s[0-9]+:[0-9]+:[0-9]+\\S+$"); +const std::regex kIrqPattern("^(\\S+)\\striggered\\sat\\s\\S+$"); +const std::regex kOdpmPattern("^CH\\d+\\[(\\S+)\\],\\s(\\d+)$"); +const std::regex kDvfsPattern("^([A-Z1-9]+):(\\d+)$"); +const std::regex kFgPattern("^(voltage_now):(\\d+)$"); +const std::regex kBatteryTempPattern("^(battery):(\\d+)$"); +const std::regex kBatteryCyclePattern("^(battery_cycle):(\\d+)$"); +const std::regex kBatterySocPattern("^(soc):(\\d+)$"); +const std::regex kAlreadyUpdatedPattern("^(LASTMEAL_UPDATED)$"); + +const std::map<std::string, int> kBrownoutReason = {{"uvlo,pmic,if", BrownoutDetected::UVLO_IF}, + {"ocp,pmic,if", BrownoutDetected::OCP_IF}, + {"uvlo,pmic,main", BrownoutDetected::UVLO_MAIN}, + {"uvlo,pmic,sub", BrownoutDetected::UVLO_SUB}, + {"ocp,buck1m", BrownoutDetected::OCP_B1M}, + {"ocp,buck2m", BrownoutDetected::OCP_B2M}, + {"ocp,buck3m", BrownoutDetected::OCP_B3M}, + {"ocp,buck4m", BrownoutDetected::OCP_B4M}, + {"ocp,buck5m", BrownoutDetected::OCP_B5M}, + {"ocp,buck6m", BrownoutDetected::OCP_B6M}, + {"ocp,buck7m", BrownoutDetected::OCP_B7M}, + {"ocp,buck8m", BrownoutDetected::OCP_B8M}, + {"ocp,buck9m", BrownoutDetected::OCP_B9M}, + {"ocp,buck10m", BrownoutDetected::OCP_B10M}, + {"ocp,buck1s", BrownoutDetected::OCP_B1S}, + {"ocp,buck2s", BrownoutDetected::OCP_B2S}, + {"ocp,buck3s", BrownoutDetected::OCP_B3S}, + {"ocp,buck4s", BrownoutDetected::OCP_B4S}, + {"ocp,buck5s", BrownoutDetected::OCP_B5S}, + {"ocp,buck6s", BrownoutDetected::OCP_B6S}, + {"ocp,buck7s", BrownoutDetected::OCP_B7S}, + {"ocp,buck8s", BrownoutDetected::OCP_B8S}, + {"ocp,buck9s", BrownoutDetected::OCP_B9S}, + {"ocp,buck10s", BrownoutDetected::OCP_B10S}, + {"ocp,buckas", BrownoutDetected::OCP_BAS}, + {"ocp,buckbs", BrownoutDetected::OCP_BBS}, + {"ocp,buckcs", BrownoutDetected::OCP_BCS}, + {"ocp,buckds", BrownoutDetected::OCP_BDS}}; + +bool BrownoutDetectedReporter::updateIfFound(std::string line, std::regex pattern, + int *current_value, Update flag) { + bool found = false; + std::smatch pattern_match; + if (std::regex_match(line, pattern_match, pattern)) { + if (pattern_match.size() < (READING_IDX + 1)) { + return found; + } + found = true; + int reading = std::stoi(pattern_match[READING_IDX].str()); + if (flag == kUpdateMax) { + if (*current_value < reading) { + *current_value = reading; + } + } else { + if (*current_value > reading) { + *current_value = reading; + } + } + } + return found; +} + +void BrownoutDetectedReporter::setAtomFieldValue(std::vector<VendorAtomValue> *values, int offset, + int content) { + std::vector<VendorAtomValue> &val = *values; + if (offset - kVendorAtomOffset < val.size()) { + val[offset - kVendorAtomOffset].set<VendorAtomValue::intValue>(content); + } +} + +void BrownoutDetectedReporter::uploadData(const std::shared_ptr<IStats> &stats_client, + const struct BrownoutDetectedInfo max_value) { + // Load values array + VendorAtomValue tmp; + std::vector<VendorAtomValue> values(37); + setAtomFieldValue(&values, BrownoutDetected::kTriggeredIrqFieldNumber, + max_value.triggered_irq_); + setAtomFieldValue(&values, BrownoutDetected::kTriggeredTimestampFieldNumber, + max_value.triggered_timestamp_); + setAtomFieldValue(&values, BrownoutDetected::kBatteryTempFieldNumber, max_value.battery_temp_); + setAtomFieldValue(&values, BrownoutDetected::kBatterySocFieldNumber, + 100 - max_value.battery_soc_); + setAtomFieldValue(&values, BrownoutDetected::kBatteryCycleFieldNumber, + max_value.battery_cycle_); + setAtomFieldValue(&values, BrownoutDetected::kVoltageNowFieldNumber, max_value.voltage_now_); + + setAtomFieldValue(&values, BrownoutDetected::kOdpmChannel01FieldNumber, + max_value.odpm_value_[0]); + setAtomFieldValue(&values, BrownoutDetected::kOdpmChannel02FieldNumber, + max_value.odpm_value_[1]); + setAtomFieldValue(&values, BrownoutDetected::kOdpmChannel03FieldNumber, + max_value.odpm_value_[2]); + setAtomFieldValue(&values, BrownoutDetected::kOdpmChannel04FieldNumber, + max_value.odpm_value_[3]); + setAtomFieldValue(&values, BrownoutDetected::kOdpmChannel05FieldNumber, + max_value.odpm_value_[4]); + setAtomFieldValue(&values, BrownoutDetected::kOdpmChannel06FieldNumber, + max_value.odpm_value_[5]); + setAtomFieldValue(&values, BrownoutDetected::kOdpmChannel07FieldNumber, + max_value.odpm_value_[6]); + setAtomFieldValue(&values, BrownoutDetected::kOdpmChannel08FieldNumber, + max_value.odpm_value_[7]); + setAtomFieldValue(&values, BrownoutDetected::kOdpmChannel09FieldNumber, + max_value.odpm_value_[8]); + setAtomFieldValue(&values, BrownoutDetected::kOdpmChannel10FieldNumber, + max_value.odpm_value_[9]); + setAtomFieldValue(&values, BrownoutDetected::kOdpmChannel11FieldNumber, + max_value.odpm_value_[10]); + setAtomFieldValue(&values, BrownoutDetected::kOdpmChannel12FieldNumber, + max_value.odpm_value_[11]); + setAtomFieldValue(&values, BrownoutDetected::kOdpmChannel13FieldNumber, + max_value.odpm_value_[12]); + setAtomFieldValue(&values, BrownoutDetected::kOdpmChannel14FieldNumber, + max_value.odpm_value_[13]); + setAtomFieldValue(&values, BrownoutDetected::kOdpmChannel15FieldNumber, + max_value.odpm_value_[14]); + setAtomFieldValue(&values, BrownoutDetected::kOdpmChannel16FieldNumber, + max_value.odpm_value_[15]); + setAtomFieldValue(&values, BrownoutDetected::kOdpmChannel17FieldNumber, + max_value.odpm_value_[16]); + setAtomFieldValue(&values, BrownoutDetected::kOdpmChannel18FieldNumber, + max_value.odpm_value_[17]); + setAtomFieldValue(&values, BrownoutDetected::kOdpmChannel19FieldNumber, + max_value.odpm_value_[18]); + setAtomFieldValue(&values, BrownoutDetected::kOdpmChannel20FieldNumber, + max_value.odpm_value_[19]); + setAtomFieldValue(&values, BrownoutDetected::kOdpmChannel21FieldNumber, + max_value.odpm_value_[20]); + setAtomFieldValue(&values, BrownoutDetected::kOdpmChannel22FieldNumber, + max_value.odpm_value_[21]); + setAtomFieldValue(&values, BrownoutDetected::kOdpmChannel23FieldNumber, + max_value.odpm_value_[22]); + setAtomFieldValue(&values, BrownoutDetected::kOdpmChannel24FieldNumber, + max_value.odpm_value_[23]); + + setAtomFieldValue(&values, BrownoutDetected::kDvfsChannel1FieldNumber, + max_value.dvfs_value_[0]); + setAtomFieldValue(&values, BrownoutDetected::kDvfsChannel2FieldNumber, + max_value.dvfs_value_[1]); + setAtomFieldValue(&values, BrownoutDetected::kDvfsChannel3FieldNumber, + max_value.dvfs_value_[2]); + setAtomFieldValue(&values, BrownoutDetected::kDvfsChannel4FieldNumber, + max_value.dvfs_value_[3]); + setAtomFieldValue(&values, BrownoutDetected::kDvfsChannel5FieldNumber, + max_value.dvfs_value_[4]); + setAtomFieldValue(&values, BrownoutDetected::kDvfsChannel6FieldNumber, + max_value.dvfs_value_[5]); + setAtomFieldValue(&values, BrownoutDetected::kBrownoutReasonFieldNumber, + max_value.brownout_reason_); + + // Send vendor atom to IStats HAL + VendorAtom event = {.reverseDomainName = "", + .atomId = PixelAtoms::Atom::kBrownoutDetected, + .values = std::move(values)}; + const ndk::ScopedAStatus ret = stats_client->reportVendorAtom(event); + if (!ret.isOk()) + ALOGE("Unable to report ChargeStats to Stats service"); +} + +long BrownoutDetectedReporter::parseTimestamp(std::string timestamp) { + struct tm triggeredTimestamp = {}; + std::string timestampFormat = "%Y-%m-%d %H:%M:%S"; + if (strptime(timestamp.substr(0, 19).c_str(), timestampFormat.c_str(), &triggeredTimestamp)) { + auto logFileTime = std::chrono::system_clock::from_time_t(mktime(&triggeredTimestamp)); + return logFileTime.time_since_epoch().count(); + } + return 0; +} + +void BrownoutDetectedReporter::logBrownout(const std::shared_ptr<IStats> &stats_client, + const std::string &logFilePath, + const std::string &brownoutReasonProp) { + std::string logFile; + if (!android::base::ReadFileToString(logFilePath, &logFile)) { + return; + } + std::istringstream content(logFile); + std::string line; + struct BrownoutDetectedInfo max_value = {}; + max_value.voltage_now_ = DEFAULT_BATTERY_VOLT; + max_value.battery_soc_ = DEFAULT_BATTERY_SOC; + max_value.battery_temp_ = DEFAULT_BATTERY_TEMP; + std::smatch pattern_match; + int odpm_index = 0, dvfs_index = 0; + std::string reason = android::base::GetProperty(brownoutReasonProp.c_str(), ""); + if (reason.empty()) { + // Brownout not found + return; + } + + auto key = kBrownoutReason.find(reason); + if (key == kBrownoutReason.end()) { + return; + } + max_value.brownout_reason_ = key->second; + bool isAlreadyUpdated = false; + while (std::getline(content, line)) { + if (std::regex_match(line, pattern_match, kAlreadyUpdatedPattern)) { + isAlreadyUpdated = true; + break; + } + if (std::regex_match(line, pattern_match, kIrqPattern)) { + if (pattern_match.size() < (KEY_IDX + 1)) { + return; + } + std::ssub_match irq = pattern_match[KEY_IDX]; + if (irq.str().find("batoilo") != std::string::npos) { + max_value.triggered_irq_ = BrownoutDetected::BATOILO; + continue; + } + if (irq.str().find("vdroop1") != std::string::npos) { + max_value.triggered_irq_ = BrownoutDetected::UVLO1; + continue; + } + if (irq.str().find("vdroop2") != std::string::npos) { + max_value.triggered_irq_ = BrownoutDetected::UVLO2; + continue; + } + if (irq.str().find("smpl_gm") != std::string::npos) { + max_value.triggered_irq_ = BrownoutDetected::SMPL_WARN; + continue; + } + continue; + } + if (std::regex_match(line, pattern_match, kTimestampPattern)) { + max_value.triggered_timestamp_ = parseTimestamp(line.c_str()); + continue; + } + if (updateIfFound(line, kBatterySocPattern, &max_value.battery_soc_, kUpdateMax)) { + continue; + } + if (updateIfFound(line, kBatteryTempPattern, &max_value.battery_temp_, kUpdateMin)) { + continue; + } + if (updateIfFound(line, kBatteryCyclePattern, &max_value.battery_cycle_, kUpdateMax)) { + continue; + } + if (updateIfFound(line, kFgPattern, &max_value.voltage_now_, kUpdateMin)) { + continue; + } + if (updateIfFound(line, kDvfsPattern, &max_value.dvfs_value_[dvfs_index], kUpdateMax)) { + dvfs_index++; + // Discarding previous value and update with new DVFS value + if (dvfs_index == DVFS_MAX_IDX) { + dvfs_index = 0; + } + continue; + } + if (updateIfFound(line, kOdpmPattern, &max_value.odpm_value_[odpm_index], kUpdateMax)) { + odpm_index++; + // Discarding previous value and update with new ODPM value + if (odpm_index == ODPM_MAX_IDX) { + odpm_index = 0; + } + continue; + } + } + if (!isAlreadyUpdated && max_value.battery_temp_ != DEFAULT_BATTERY_TEMP) { + std::string file_content = "LASTMEAL_UPDATED\n" + logFile; + android::base::WriteStringToFile(file_content, logFilePath); + uploadData(stats_client, max_value); + } +} + +} // namespace pixel +} // namespace google +} // namespace hardware +} // namespace android diff --git a/pixelstats/ChargeStatsReporter.cpp b/pixelstats/ChargeStatsReporter.cpp index 8bc27201..e3727b85 100644 --- a/pixelstats/ChargeStatsReporter.cpp +++ b/pixelstats/ChargeStatsReporter.cpp @@ -39,27 +39,35 @@ using android::base::WriteStringToFile; using android::hardware::google::pixel::PixelAtoms::ChargeStats; using android::hardware::google::pixel::PixelAtoms::VoltageTierStats; +#define DURATION_FILTER_SECS 15 + ChargeStatsReporter::ChargeStatsReporter() {} +int64_t ChargeStatsReporter::getTimeSecs(void) { + return nanoseconds_to_seconds(systemTime(SYSTEM_TIME_BOOTTIME)); +} + void ChargeStatsReporter::ReportChargeStats(const std::shared_ptr<IStats> &stats_client, const std::string line, const std::string wline_at, const std::string wline_ac, const std::string pca_line) { - int charge_stats_fields[] = {ChargeStats::kAdapterTypeFieldNumber, - ChargeStats::kAdapterVoltageFieldNumber, - ChargeStats::kAdapterAmperageFieldNumber, - ChargeStats::kSsocInFieldNumber, - ChargeStats::kVoltageInFieldNumber, - ChargeStats::kSsocOutFieldNumber, - ChargeStats::kVoltageOutFieldNumber, - ChargeStats::kAdapterCapabilities0FieldNumber, - ChargeStats::kAdapterCapabilities1FieldNumber, - ChargeStats::kAdapterCapabilities2FieldNumber, - ChargeStats::kAdapterCapabilities3FieldNumber, - ChargeStats::kAdapterCapabilities4FieldNumber, - ChargeStats::kReceiverState0FieldNumber, - ChargeStats::kReceiverState1FieldNumber, - ChargeStats::kChargeCapacityFieldNumber}; + int charge_stats_fields[] = { + ChargeStats::kAdapterTypeFieldNumber, + ChargeStats::kAdapterVoltageFieldNumber, + ChargeStats::kAdapterAmperageFieldNumber, + ChargeStats::kSsocInFieldNumber, + ChargeStats::kVoltageInFieldNumber, + ChargeStats::kSsocOutFieldNumber, + ChargeStats::kVoltageOutFieldNumber, + ChargeStats::kChargeCapacityFieldNumber, + ChargeStats::kAdapterCapabilities0FieldNumber, + ChargeStats::kAdapterCapabilities1FieldNumber, + ChargeStats::kAdapterCapabilities2FieldNumber, + ChargeStats::kAdapterCapabilities3FieldNumber, + ChargeStats::kAdapterCapabilities4FieldNumber, + ChargeStats::kReceiverState0FieldNumber, + ChargeStats::kReceiverState1FieldNumber, + }; const int32_t chg_fields_size = std::size(charge_stats_fields); static_assert(chg_fields_size == 15, "Unexpected charge stats fields size"); const int32_t wlc_fields_size = 7; @@ -70,7 +78,7 @@ void ChargeStatsReporter::ReportChargeStats(const std::shared_ptr<IStats> &stats ALOGD("processing %s", line.c_str()); if (sscanf(line.c_str(), "%d,%d,%d, %d,%d,%d,%d %d", &tmp[0], &tmp[1], &tmp[2], &tmp[3], - &tmp[4], &tmp[5], &tmp[6], &tmp[14]) == 8) { + &tmp[4], &tmp[5], &tmp[6], &tmp[7]) == 8) { /* Age Adjusted Charge Rate (AACR) logs an additional battery capacity in order to determine * the charge curve needed to minimize battery cycle life degradation, while also minimizing * impact to the user. @@ -89,8 +97,8 @@ void ChargeStatsReporter::ReportChargeStats(const std::shared_ptr<IStats> &stats } else { tmp[0] = wireless_charge_stats_.TranslateSysModeToAtomValue(ssoc_tmp); ALOGD("wlc: processing %s", wline_ac.c_str()); - if (sscanf(wline_ac.c_str(), "D:%x,%x,%x,%x,%x, %x,%x", &tmp[7], &tmp[8], &tmp[9], - &tmp[10], &tmp[11], &tmp[12], &tmp[13]) != 7) + if (sscanf(wline_ac.c_str(), "D:%x,%x,%x,%x,%x, %x,%x", &tmp[8], &tmp[9], &tmp[10], + &tmp[11], &tmp[12], &tmp[13], &tmp[14]) != 7) ALOGE("Couldn't process %s", wline_ac.c_str()); else fields_size = chg_fields_size; /* include wlc stats */ @@ -104,14 +112,14 @@ void ChargeStatsReporter::ReportChargeStats(const std::shared_ptr<IStats> &stats ALOGE("Couldn't process %s", pca_line.c_str()); } else { fields_size = chg_fields_size; /* include pca stats */ - tmp[9] = pca_rs[2]; - tmp[10] = pca_rs[3]; - tmp[11] = pca_rs[4]; - tmp[13] = pca_rs[1]; + tmp[10] = pca_rs[2]; + tmp[11] = pca_rs[3]; + tmp[12] = pca_rs[4]; + tmp[14] = pca_rs[1]; if (wline_at.empty()) { - tmp[7] = pca_ac[0]; - tmp[8] = pca_ac[1]; - tmp[12] = pca_rs[0]; + tmp[8] = pca_ac[0]; + tmp[9] = pca_ac[1]; + tmp[13] = pca_rs[0]; } } } @@ -198,14 +206,38 @@ void ChargeStatsReporter::ReportVoltageTierStats(const std::shared_ptr<IStats> & ALOGE("Unable to report VoltageTierStats to Stats service"); } +/** + * b/223664185 + * Adds a rolling window filter to charge stats. If the time has expired, there will be a new log + * event. + * + * This helps ensure that we throttle stats even if there is an intermittent disconnect, while still + * retaining some stats on the disconnect. + */ +bool ChargeStatsReporter::shouldReportEvent(void) { + const int64_t current_time = getTimeSecs(); + if (current_time == 0) { + ALOGE("Current boot time is zero!"); + return false; + } + + if (log_event_time_secs_ == 0 || log_event_time_secs_ + DURATION_FILTER_SECS < current_time) { + log_event_time_secs_ = current_time; + return true; + } + + return false; +} + void ChargeStatsReporter::checkAndReport(const std::shared_ptr<IStats> &stats_client, const std::string &path) { std::string file_contents, line, wfile_contents, wline_at, wline_ac, pca_file_contents, - pca_line, thermal_file_contents; + pca_line, thermal_file_contents, gcharger_file_contents; std::istringstream ss; bool has_wireless = wireless_charge_stats_.CheckWirelessContentsAndAck(&wfile_contents); bool has_pca = pca_charge_stats_.CheckPcaContentsAndAck(&pca_file_contents); - bool has_thermal = checkThermalContentsAndAck(&thermal_file_contents); + bool has_thermal = checkContentsAndAck(&thermal_file_contents, kThermalChargeMetricsPath); + bool has_gcharger = checkContentsAndAck(&gcharger_file_contents, kGChargerMetricsPath); if (!ReadFileToString(path.c_str(), &file_contents)) { ALOGE("Unable to read %s - %s", path.c_str(), strerror(errno)); @@ -223,6 +255,11 @@ void ChargeStatsReporter::checkAndReport(const std::shared_ptr<IStats> &stats_cl ALOGE("Couldn't clear %s - %s", path.c_str(), strerror(errno)); } + if (!shouldReportEvent()) { + ALOGW("Too many log events; event ignored."); + return; + } + if (has_pca) { std::istringstream pca_ss; @@ -255,15 +292,23 @@ void ChargeStatsReporter::checkAndReport(const std::shared_ptr<IStats> &stats_cl ReportVoltageTierStats(stats_client, line.c_str()); } } + + if (has_gcharger) { + std::istringstream wss; + wss.str(gcharger_file_contents); + while (std::getline(wss, line)) { + ReportVoltageTierStats(stats_client, line.c_str()); + } + } } -bool ChargeStatsReporter::checkThermalContentsAndAck(std::string *file_contents) { - if (!ReadFileToString(kThermalChargeMetricsPath.c_str(), file_contents)) { +bool ChargeStatsReporter::checkContentsAndAck(std::string *file_contents, const std::string &path) { + if (!ReadFileToString(path.c_str(), file_contents)) { return false; } - if (!WriteStringToFile("0", kThermalChargeMetricsPath.c_str())) { - ALOGE("Couldn't clear %s - %s", kThermalChargeMetricsPath.c_str(), strerror(errno)); + if (!WriteStringToFile("0", path.c_str())) { + ALOGE("Couldn't clear %s - %s", path.c_str(), strerror(errno)); return false; } return true; diff --git a/pixelstats/MmMetricsReporter.cpp b/pixelstats/MmMetricsReporter.cpp index 558fd2dc..10a97294 100644 --- a/pixelstats/MmMetricsReporter.cpp +++ b/pixelstats/MmMetricsReporter.cpp @@ -18,6 +18,7 @@ #include <aidl/android/frameworks/stats/IStats.h> #include <android-base/file.h> +#include <android-base/parsedouble.h> #include <android-base/parseint.h> #include <android-base/properties.h> #include <android-base/stringprintf.h> @@ -53,13 +54,13 @@ const std::vector<MmMetricsReporter::MmMetricsInfo> MmMetricsReporter::kMmMetric {"nr_anon_pages", PixelMmMetricsPerHour::kAnonPagesFieldNumber, false}, {"nr_file_pages", PixelMmMetricsPerHour::kFilePagesFieldNumber, false}, {"nr_slab_reclaimable", PixelMmMetricsPerHour::kSlabReclaimableFieldNumber, false}, + {"nr_slab_unreclaimable", PixelMmMetricsPerHour::kSlabUnreclaimableFieldNumber, false}, {"nr_zspages", PixelMmMetricsPerHour::kZspagesFieldNumber, false}, {"nr_unevictable", PixelMmMetricsPerHour::kUnevictableFieldNumber, false}, }; const std::vector<MmMetricsReporter::MmMetricsInfo> MmMetricsReporter::kMmMetricsPerDayInfo = { {"workingset_refault", PixelMmMetricsPerDay::kWorkingsetRefaultFieldNumber, true}, - {"workingset_refault_file", PixelMmMetricsPerDay::kWorkingsetRefaultFieldNumber, true}, {"pswpin", PixelMmMetricsPerDay::kPswpinFieldNumber, true}, {"pswpout", PixelMmMetricsPerDay::kPswpoutFieldNumber, true}, {"allocstall_dma", PixelMmMetricsPerDay::kAllocstallDmaFieldNumber, true}, @@ -78,6 +79,18 @@ const std::vector<MmMetricsReporter::MmMetricsInfo> MmMetricsReporter::kMmMetric {"pgalloc_costly_order", PixelMmMetricsPerDay::kPgallocHighFieldNumber, true}, {"pgcache_hit", PixelMmMetricsPerDay::kPgcacheHitFieldNumber, true}, {"pgcache_miss", PixelMmMetricsPerDay::kPgcacheMissFieldNumber, true}, + {"workingset_refault_file", PixelMmMetricsPerDay::kWorkingsetRefaultFileFieldNumber, true}, + {"workingset_refault_anon", PixelMmMetricsPerDay::kWorkingsetRefaultAnonFieldNumber, true}, + {"compact_success", PixelMmMetricsPerDay::kCompactSuccessFieldNumber, true}, + {"compact_fail", PixelMmMetricsPerDay::kCompactFailFieldNumber, true}, + {"kswapd_low_wmark_hit_quickly", PixelMmMetricsPerDay::kKswapdLowWmarkHqFieldNumber, true}, + {"kswapd_high_wmark_hit_quickly", PixelMmMetricsPerDay::kKswapdHighWmarkHqFieldNumber, + true}, + {"thp_file_alloc", PixelMmMetricsPerDay::kThpFileAllocFieldNumber, true}, + {"thp_zero_page_alloc", PixelMmMetricsPerDay::kThpZeroPageAllocFieldNumber, true}, + {"thp_split_page", PixelMmMetricsPerDay::kThpSplitPageFieldNumber, true}, + {"thp_migration_split", PixelMmMetricsPerDay::kThpMigrationSplitFieldNumber, true}, + {"thp_deferred_split_page", PixelMmMetricsPerDay::kThpDeferredSplitPageFieldNumber, true}, }; const std::vector<MmMetricsReporter::MmMetricsInfo> MmMetricsReporter::kCmaStatusInfo = { @@ -146,7 +159,11 @@ MmMetricsReporter::MmMetricsReporter() kIonTotalPoolsPath("/sys/kernel/dma_heap/total_pools_kb"), kIonTotalPoolsPathForLegacy("/sys/kernel/ion/total_pools_kb"), kGpuTotalPages("/sys/kernel/pixel_stat/gpu/mem/total_page_count"), - kPixelStatMm("/sys/kernel/pixel_stat/mm") { + kCompactDuration("/sys/kernel/pixel_stat/mm/compaction/mm_compaction_duration"), + kDirectReclaimBasePath("/sys/kernel/pixel_stat/mm/vmscan/direct_reclaim"), + kPixelStatMm("/sys/kernel/pixel_stat/mm"), + prev_compaction_duration_(kNumCompactionDurationPrevMetrics, 0), + prev_direct_reclaim_(kNumDirectReclaimPrevMetrics, 0) { is_user_build_ = checkUserBuild(); ker_mm_metrics_support_ = checkKernelMMMetricSupport(); } @@ -170,6 +187,90 @@ bool MmMetricsReporter::ReadFileToUint(const char *const path, uint64_t *val) { return true; } +/* + * This function reads whole file and parses tokens separated by <delim> into + * long integers. Useful for direct reclaim & compaction duration sysfs nodes. + * Data write is using all or none policy: It will not write partial data unless + * all data values are good. + * + * path: file to open/read + * data: where to store the results + * start_idx: index into data[] where to start saving the results + * delim: delimiters separating different longs + * skip: how many resulting longs to skip before saving + * nonnegtive: set to true to validate positive numbers + * + * Return value: number of longs actually stored on success. negative + * error codes on errors. + */ +static int ReadFileToLongs(const std::string &path, std::vector<long> *data, int start_idx, + const char *delim, int skip, bool nonnegative = false) { + std::vector<long> out; + enum { err_read_file = -1, err_parse = -2 }; + std::string file_contents; + + if (!ReadFileToString(path, &file_contents)) { + // Don't print this log if the file doesn't exist, since logs will be printed repeatedly. + if (errno != ENOENT) { + ALOGI("Unable to read %s - %s", path.c_str(), strerror(errno)); + } + return err_read_file; + } + + file_contents = android::base::Trim(file_contents); + std::vector<std::string> words = android::base::Tokenize(file_contents, delim); + if (words.size() == 0) + return 0; + + for (auto &w : words) { + if (skip) { + skip--; + continue; + } + long tmp; + if (!android::base::ParseInt(w, &tmp) || (nonnegative && tmp < 0)) + return err_parse; + out.push_back(tmp); + } + + int min_size = std::max(static_cast<int>(out.size()) + start_idx, 0); + if (min_size > data->size()) + data->resize(min_size); + std::copy(out.begin(), out.end(), data->begin() + start_idx); + + return out.size(); +} + +/* + * This function calls ReadFileToLongs, and checks the expected number + * of long integers read. Useful for direct reclaim & compaction duration + * sysfs nodes. + * + * path: file to open/read + * data: where to store the results + * start_idx: index into data[] where to start saving the results + * delim: delimiters separating different longs + * skip: how many resulting longs to skip before saving + * expected_num: number of expected longs to be read. + * nonnegtive: set to true to validate positive numbers + * + * Return value: true if successfully get expected number of long values. + * otherwise false. + */ +static inline bool ReadFileToLongsCheck(const std::string &path, std::vector<long> *store, + int start_idx, const char *delim, int skip, + int expected_num, bool nonnegative = false) { + int num = ReadFileToLongs(path, store, start_idx, delim, skip, nonnegative); + + if (num == expected_num) + return true; + + int last_idx = std::min(start_idx + expected_num, static_cast<int>(store->size())); + std::fill(store->begin() + start_idx, store->begin() + last_idx, -1); + + return false; +} + bool MmMetricsReporter::reportVendorAtom(const std::shared_ptr<IStats> &stats_client, int atom_id, const std::vector<VendorAtomValue> &values, const std::string &atom_name) { @@ -272,7 +373,7 @@ void MmMetricsReporter::fillAtomValues(const std::vector<MmMetricsInfo> &metrics if (max_idx < entry.atom_key) max_idx = entry.atom_key; } - int size = max_idx - kVendorAtomOffset + 1; + unsigned int size = max_idx - kVendorAtomOffset + 1; if (atom_values->size() < size) atom_values->resize(size, tmp); @@ -301,6 +402,10 @@ void MmMetricsReporter::fillAtomValues(const std::vector<MmMetricsInfo> &metrics (*prev_mm_metrics) = mm_metrics; } +void MmMetricsReporter::aggregatePixelMmMetricsPer5Min() { + aggregatePressureStall(); +} + void MmMetricsReporter::logPixelMmMetricsPerHour(const std::shared_ptr<IStats> &stats_client) { if (!MmMetricsSupported()) return; @@ -312,28 +417,23 @@ void MmMetricsReporter::logPixelMmMetricsPerHour(const std::shared_ptr<IStats> & uint64_t ion_total_pools = getIonTotalPools(); uint64_t gpu_memory = getGpuMemory(); - std::vector<VendorAtomValue> values; - bool is_first_atom = (prev_hour_vmstat_.size() == 0) ? true : false; - fillAtomValues(kMmMetricsPerHourInfo, vmstat, &prev_hour_vmstat_, &values); - - // resize values to add the following fields + // allocate enough values[] entries for the metrics. VendorAtomValue tmp; tmp.set<VendorAtomValue::longValue>(0); - int size = PixelMmMetricsPerHour::kGpuMemoryFieldNumber - kVendorAtomOffset + 1; - if (values.size() < size) { - values.resize(size, tmp); - } + int last_value_index = + PixelMmMetricsPerHour::kPsiMemSomeAvg300AvgFieldNumber - kVendorAtomOffset; + std::vector<VendorAtomValue> values(last_value_index + 1, tmp); + + fillAtomValues(kMmMetricsPerHourInfo, vmstat, &prev_hour_vmstat_, &values); tmp.set<VendorAtomValue::longValue>(ion_total_pools); values[PixelMmMetricsPerHour::kIonTotalPoolsFieldNumber - kVendorAtomOffset] = tmp; tmp.set<VendorAtomValue::longValue>(gpu_memory); values[PixelMmMetricsPerHour::kGpuMemoryFieldNumber - kVendorAtomOffset] = tmp; + fillPressureStallAtom(&values); - // Don't report the first atom to avoid big spike in accumulated values. - if (!is_first_atom) { - // Send vendor atom to IStats HAL - reportVendorAtom(stats_client, PixelAtoms::Atom::kPixelMmMetricsPerHour, values, - "PixelMmMetricsPerHour"); - } + // Send vendor atom to IStats HAL + reportVendorAtom(stats_client, PixelAtoms::Atom::kPixelMmMetricsPerHour, values, + "PixelMmMetricsPerHour"); } void MmMetricsReporter::logPixelMmMetricsPerDay(const std::shared_ptr<IStats> &stats_client) { @@ -344,8 +444,21 @@ void MmMetricsReporter::logPixelMmMetricsPerDay(const std::shared_ptr<IStats> &s if (vmstat.size() == 0) return; - std::vector<VendorAtomValue> values; + std::vector<long> direct_reclaim; + readDirectReclaimStat(&direct_reclaim); + + std::vector<long> compaction_duration; + readCompactionDurationStat(&compaction_duration); + bool is_first_atom = (prev_day_vmstat_.size() == 0) ? true : false; + + // allocate enough values[] entries for the metrics. + VendorAtomValue tmp; + tmp.set<VendorAtomValue::longValue>(0); + int last_value_index = + PixelMmMetricsPerDay::kThpDeferredSplitPageFieldNumber - kVendorAtomOffset; + std::vector<VendorAtomValue> values(last_value_index + 1, tmp); + fillAtomValues(kMmMetricsPerDayInfo, vmstat, &prev_day_vmstat_, &values); std::map<std::string, uint64_t> pixel_vmstat = @@ -355,6 +468,8 @@ void MmMetricsReporter::logPixelMmMetricsPerDay(const std::shared_ptr<IStats> &s &prev_kswapd_stime_, &values); fillProcessStime(PixelMmMetricsPerDay::kKcompactdStimeClksFieldNumber, "kcompactd0", &kcompactd_pid_, &prev_kcompactd_stime_, &values); + fillDirectReclaimStatAtom(direct_reclaim, &values); + fillCompactionDurationStatAtom(direct_reclaim, &values); // Don't report the first atom to avoid big spike in accumulated values. if (!is_first_atom) { @@ -432,7 +547,7 @@ uint64_t MmMetricsReporter::getStimeByPid(int pid) { std::vector<std::string> data = android::base::Split(file_contents, " "); if (data.size() < stime_idx) { - ALOGI("Unable to find stime from %s. size: %lu", path.c_str(), data.size()); + ALOGI("Unable to find stime from %s. size: %zu", path.c_str(), data.size()); return false; } @@ -498,6 +613,544 @@ std::map<std::string, uint64_t> MmMetricsReporter::readCmaStat( } /** + * This function reads compaction duration sysfs node + * (/sys/kernel/pixel_stat/mm/compaction/mm_compaction_duration) + * + * store: vector to save compaction duration info + */ +void MmMetricsReporter::readCompactionDurationStat(std::vector<long> *store) { + static const std::string path(kCompactDuration); + constexpr int num_metrics = 6; + + store->resize(num_metrics); + + int start_idx = 0; + int expected_num = num_metrics; + + if (!ReadFileToLongsCheck(path, store, start_idx, " ", 1, expected_num, true)) { + ALOGI("Unable to read %s for the direct reclaim info.", path.c_str()); + } +} + +/** + * This function fills atom values (values) from acquired compaction duration + * information from vector store + * + * store: the already collected (by readCompactionDurationStat()) compaction + * duration information + * values: the atom value vector to be filled. + */ +void MmMetricsReporter::fillCompactionDurationStatAtom(const std::vector<long> &store, + std::vector<VendorAtomValue> *values) { + // first metric index + constexpr int start_idx = PixelMmMetricsPerDay::kCompactionTotalTimeFieldNumber; + constexpr int num_metrics = 6; + + if (!MmMetricsSupported()) + return; + + int size = start_idx + num_metrics - kVendorAtomOffset; + if (values->size() < size) + values->resize(size); + + for (int i = 0; i < num_metrics; i++) { + VendorAtomValue tmp; + if (store[i] == -1) { + tmp.set<VendorAtomValue::longValue>(0); + } else { + tmp.set<VendorAtomValue::longValue>(store[i] - prev_compaction_duration_[i]); + prev_compaction_duration_[i] = store[i]; + } + (*values)[start_idx + i] = tmp; + } + prev_compaction_duration_ = store; +} + +/** + * This function reads direct reclaim sysfs node (4 files: + * /sys/kernel/pixel_stat/mm/vmscan/direct_reclaim/<level>/latency_stat, + * where <level> = native, top, visible, other.), and save total time and + * 4 latency information per file. Total (1+4) x 4 = 20 metrics will be + * saved. + * + * store: vector to save direct reclaim info + */ +void MmMetricsReporter::readDirectReclaimStat(std::vector<long> *store) { + static const std::string base_path(kDirectReclaimBasePath); + static const std::vector<std::string> dr_levels{"native", "top", "visible", "other"}; + static const std::string sysfs_name = "latency_stat"; + constexpr int num_metrics_per_file = 5; + int num_file = dr_levels.size(); + int num_metrics = num_metrics_per_file * num_file; + + store->resize(num_metrics); + int pass = -1; + for (auto level : dr_levels) { + ++pass; + std::string path = base_path + '/' + level + '/' + sysfs_name; + int start_idx = pass * num_metrics_per_file; + int expected_num = num_metrics_per_file; + if (!ReadFileToLongsCheck(path, store, start_idx, " ", 1, expected_num, true)) { + ALOGI("Unable to read %s for the direct reclaim info.", path.c_str()); + } + } +} + +/** + * This function fills atom values (values) from acquired direct reclaim + * information from vector store + * + * store: the already collected (by readDirectReclaimStat()) direct reclaim + * information + * values: the atom value vector to be filled. + */ +void MmMetricsReporter::fillDirectReclaimStatAtom(const std::vector<long> &store, + std::vector<VendorAtomValue> *values) { + // first metric index + constexpr int start_idx = PixelMmMetricsPerDay::kDirectReclaimNativeLatencyTotalTimeFieldNumber; + constexpr int num_metrics = 20; /* num_metrics_per_file * num_file */ + + if (!MmMetricsSupported()) + return; + + int size = start_idx + num_metrics - kVendorAtomOffset; + if (values->size() < size) + values->resize(size); + + for (int i = 0; i < num_metrics; i++) { + VendorAtomValue tmp; + tmp.set<VendorAtomValue::longValue>(store[i] - prev_direct_reclaim_[i]); + (*values)[start_idx + i] = tmp; + } + prev_direct_reclaim_ = store; +} + +/** + * This function reads pressure (PSI) files (loop thru all 3 files: cpu, io, and + * memory) and calls the parser to parse and store the metric values. + * Note that each file have two lines (except cpu has one line only): one with + * a leading "full", and the other with a leading "some", showing the category + * for that line. + * A category has 4 metrics, avg10, avg60, avg300, and total. + * i.e. the moving average % of PSI in 10s, 60s, 300s time window plus lastly + * the total stalled time, except that 'cpu' has no 'full' category. + * In total, we have 3 x 2 x 4 - 4 = 24 - 4 = 20 metrics, arranged in + * the order of + * + * cpu_some_avg<xyz> + * cpu_some_total + * io_full_avg<xyz> + * io_full_total + * io_some_avg<xyz> + * io_some_total + * mem_full_avg<xyz> + * mem_full_total + * mem_some_avg<xyz> + * mem_some_total + * + * where <xyz>=10, 60, 300 in the order as they appear. + * + * Note that for those avg values (i.e. <abc>_<def>_avg<xyz>), they + * are in percentage with 2-decimal digit accuracy. We will use an + * integer in 2-decimal fixed point format to represent the values. + * i.e. value x 100, or to cope with floating point errors, + * floor(value x 100 + 0.5) + * + * In fact, in newer kernels, "cpu" PSI has no "full" category. Some + * old kernel has them all zeros, to keep backward compatibility. The + * parse function called by this function is able to detect and ignore + * the "cpu, full" category. + * + * sample pressure stall files: + * /proc/pressure # cat cpu + * some avg10=2.93 avg60=3.17 avg300=3.15 total=94628150260 + * /proc/pressure # cat io + * some avg10=1.06 avg60=1.15 avg300=1.18 total=37709873805 + * full avg10=1.06 avg60=1.10 avg300=1.11 total=36592322936 + * /proc/pressure # cat memory + * some avg10=0.00 avg60=0.00 avg300=0.00 total=29705314 + * full avg10=0.00 avg60=0.00 avg300=0.00 total=17234456 + * + * PSI information definitions could be found at + * https://www.kernel.org/doc/html/latest/accounting/psi.html + * + * basePath: the base path to the pressure stall information + * store: pointer to the vector to store the 20 metrics in the mentioned + * order + */ +void MmMetricsReporter::readPressureStall(const char *basePath, std::vector<long> *store) { + constexpr int kTypeIdxCpu = 0; + + // Callers should have already prepared this, but we resize it here for safety + store->resize(kPsiNumAllMetrics); + std::fill(store->begin(), store->end(), -1); + + // To make the process unified, we prepend an imaginary "cpu + full" + // type-category combination. Now, each file (cpu, io, memnry) contains + // two categories, i.e. "full" and "some". + // Each category has <kPsiNumNames> merics and thus need that many entries + // to store them, except that the first category (the imaginary one) do not + // need any storage. So we set the save index for the 1st file ("cpu") to + // -kPsiNumNames. + int file_save_idx = -kPsiNumNames; + + // loop thru all pressure stall files: cpu, io, memory + for (int type_idx = 0; type_idx < kPsiNumFiles; + ++type_idx, file_save_idx += kPsiMetricsPerFile) { + std::string file_contents; + std::string path = std::string("") + basePath + '/' + kPsiTypes[type_idx]; + + if (!ReadFileToString(path, &file_contents)) { + // Don't print this log if the file doesn't exist, since logs will be printed + // repeatedly. + if (errno != ENOENT) + ALOGI("Unable to read %s - %s", path.c_str(), strerror(errno)); + goto err_out; + } + if (!MmMetricsReporter::parsePressureStallFileContent(type_idx == kTypeIdxCpu, + file_contents, store, file_save_idx)) + goto err_out; + } + return; + +err_out: + std::fill(store->begin(), store->end(), -1); +} + +/* + * This function parses a pressure stall file, which contains two + * lines, i.e. the "full", and "some" lines, except that the 'cpu' file + * contains only one line ("some"). Refer to the function comments of + * readPressureStall() for pressure stall file format. + * + * For old kernel, 'cpu' file might contain an extra line for "full", which + * will be ignored. + * + * is_cpu: Is the data from the file 'cpu' + * lines: the file content + * store: the output vector to hold the parsed data. + * file_save_idx: base index to start saving 'store' vector for this file. + * + * Return value: true on success, false otherwise. + */ +bool MmMetricsReporter::parsePressureStallFileContent(bool is_cpu, std::string lines, + std::vector<long> *store, int file_save_idx) { + constexpr int kNumOfWords = 5; // expected number of words separated by spaces. + constexpr int kCategoryFull = 0; + + std::istringstream data(lines); + std::string line; + + while (std::getline(data, line)) { + int category_idx = 0; + + line = android::base::Trim(line); + std::vector<std::string> words = android::base::Tokenize(line, " "); + if (words.size() != kNumOfWords) { + ALOGE("PSI parse fail: num of words = %d != expected %d", + static_cast<int>(words.size()), kNumOfWords); + return false; + } + + // words[0] should be either "full" or "some", the category name. + for (auto &cat : kPsiCategories) { + if (words[0].compare(cat) == 0) + break; + ++category_idx; + } + if (category_idx == kPsiNumCategories) { + ALOGE("PSI parse fail: unknown category %s", words[0].c_str()); + return false; + } + + // skip (cpu, full) combination. + if (is_cpu && category_idx == kCategoryFull) { + ALOGI("kernel: old PSI sysfs node."); + continue; + } + + // Now we have separated words in a vector, e.g. + // ["some", "avg10=2.93", "avg60=3.17", "avg300=3.15", total=94628150260"] + // call parsePressureStallWords to parse them. + int line_save_idx = file_save_idx + category_idx * kPsiNumNames; + if (!parsePressureStallWords(words, store, line_save_idx)) + return false; + } + return true; +} + +// This function parses the already split words, e.g. +// ["some", "avg10=0.00", "avg60=0.00", "avg300=0.00", "total=29705314"], +// from a line (category) in a pressure stall file. +// +// words: the split words in the form of "name=value" +// store: the output vector +// line_save_idx: the base start index to save in vector for this line (category) +// +// Return value: true on success, false otherwise. +bool MmMetricsReporter::parsePressureStallWords(std::vector<std::string> words, + std::vector<long> *store, int line_save_idx) { + // Skip the first word, which is already parsed by the caller. + // All others are value pairs in "name=value" form. + // e.g. ["some", "avg10=0.00", "avg60=0.00", "avg300=0.00", "total=29705314"] + // "some" is skipped. + for (int i = 1; i < words.size(); ++i) { + std::vector<std::string> metric = android::base::Tokenize(words[i], "="); + if (metric.size() != 2) { + ALOGE("%s: parse error (name=value) @ idx %d", __FUNCTION__, i); + return false; + } + if (!MmMetricsReporter::savePressureMetrics(metric[0], metric[1], store, line_save_idx)) + return false; + } + return true; +} + +// This function parses one value pair in "name=value" format, and depending on +// the name, save to its proper location in the store vector. +// name = "avg10" -> save to index base_save_idx. +// name = "avg60" -> save to index base_save_idx + 1. +// name = "avg300" -> save to index base_save_idx + 2. +// name = "total" -> save to index base_save_idx + 3. +// +// name: the metrics name +// value: the metrics value +// store: the output vector +// base_save_idx: the base save index +// +// Return value: true on success, false otherwise. +// +bool MmMetricsReporter::savePressureMetrics(std::string name, std::string value, + std::vector<long> *store, int base_save_idx) { + int name_idx = 0; + constexpr int kNameIdxTotal = 3; + + for (auto &mn : kPsiMetricNames) { + if (name.compare(mn) == 0) + break; + ++name_idx; + } + if (name_idx == kPsiNumNames) { + ALOGE("%s: parse error: unknown metric name.", __FUNCTION__); + return false; + } + + long out; + if (name_idx == kNameIdxTotal) { + // 'total' metrics + unsigned long tmp; + if (!android::base::ParseUint(value, &tmp)) + out = -1; + else + out = tmp; + } else { + // 'avg' metrics + double d = -1.0; + if (android::base::ParseDouble(value, &d)) + out = static_cast<long>(d * 100 + 0.5); + else + out = -1; + } + + if (base_save_idx + name_idx >= store->size()) { + // should never reach here + ALOGE("out of bound access to store[] (src line %d) @ index %d", __LINE__, + base_save_idx + name_idx); + return false; + } else { + (*store)[base_save_idx + name_idx] = out; + } + return true; +} + +/** + * This function reads in the current pressure (PSI) information, and aggregates + * it (except for the "total" information, which will overwrite + * the previous value without aggregation. + * + * data are arranged in the following order, and must comply the order defined + * in the proto: + * + * // note: these 5 'total' metrics are not aggregated. + * cpu_some_total + * io_full_total + * io_some_total + * mem_full_total + * mem_some_total + * + * // 9 aggregated metrics as above avg<xyz>_<aggregate> + * // where <xyz> = 10, 60, 300; <aggregate> = min, max, sum + * cpu_some_avg10_min + * cpu_some_avg10_max + * cpu_some_avg10_sum + * cpu_some_avg60_min + * cpu_some_avg60_max + * cpu_some_avg60_sum + * cpu_some_avg300_min + * cpu_some_avg300_max + * cpu_some_avg300_sum + * + * // similar 9 metrics as above avg<xyz>_<aggregate> + * io_full_avg<xyz>_<aggregate> + * + * // similar 9 metrics as above avg<xyz>_<aggregate> + * io_some_avg<xyz>_<aggregate> + * + * // similar 9 metrics as above avg<xyz>_<aggregate> + * mem_full_avg<xyz>_<aggregate> + * + * // similar 9 metrics as above avg<xyz>_<aggregate> + * mem_some_avg<xyz>_<aggregate> + * + * In addition, it increases psi_data_set_count_ by 1 (in order to calculate + * the average from the "_sum" aggregate.) + */ +void MmMetricsReporter::aggregatePressureStall() { + constexpr int kFirstTotalOffset = kPsiNumAvgs; + + if (!MmMetricsSupported()) + return; + + std::vector<long> psi(kPsiNumAllMetrics, -1); + readPressureStall(kPsiBasePath, &psi); + + // Pre-check for possible later out of bound error, if readPressureStall() + // decreases the vector size. + // It's for safety only. The condition should never be true. + if (psi.size() != kPsiNumAllMetrics) { + ALOGE("Wrong psi[] size %d != expected %d after read.", static_cast<int>(psi.size()), + kPsiNumAllMetrics); + return; + } + + // check raw metrics and preventively handle errors: Although we don't expect read sysfs + // node could fail. Discard all current readings on any error. + for (int i = 0; i < kPsiNumAllMetrics; ++i) { + if (psi[i] == -1) { + ALOGE("Bad data @ psi[%ld] = -1", psi[i]); + goto err_out; + } + } + + // "total" metrics are accumulative: just replace the previous accumulation. + for (int i = 0; i < kPsiNumAllTotals; ++i) { + int psi_idx; + + psi_idx = i * kPsiNumNames + kFirstTotalOffset; + if (psi_idx >= psi.size()) { + // should never reach here + ALOGE("out of bound access to psi[] (src line %d) @ index %d", __LINE__, psi_idx); + goto err_out; + } else { + psi_total_[i] = psi[psi_idx]; + } + } + + // "avg" metrics will be aggregated to min, max and sum + // later on, the sum will be divided by psi_data_set_count_ to get the average. + int aggr_idx; + aggr_idx = 0; + for (int psi_idx = 0; psi_idx < kPsiNumAllMetrics; ++psi_idx) { + if (psi_idx % kPsiNumNames == kFirstTotalOffset) + continue; // skip 'total' metrics, already processed. + + if (aggr_idx + 3 > kPsiNumAllUploadAvgMetrics) { + // should never reach here + ALOGE("out of bound access to psi_aggregated_[] (src line %d) @ index %d ~ %d", + __LINE__, aggr_idx, aggr_idx + 2); + return; // give up avgs, but keep totals (so don't go err_out + } + + long value = psi[psi_idx]; + if (psi_data_set_count_ == 0) { + psi_aggregated_[aggr_idx++] = value; + psi_aggregated_[aggr_idx++] = value; + psi_aggregated_[aggr_idx++] = value; + } else { + psi_aggregated_[aggr_idx++] = std::min(value, psi_aggregated_[aggr_idx]); + psi_aggregated_[aggr_idx++] = std::max(value, psi_aggregated_[aggr_idx]); + psi_aggregated_[aggr_idx++] += value; + } + } + ++psi_data_set_count_; + return; + +err_out: + for (int i = 0; i < kPsiNumAllTotals; ++i) psi_total_[i] = -1; +} + +/** + * This function fills atom values (values) from psi_aggregated_[] + * + * values: the atom value vector to be filled. + */ +void MmMetricsReporter::fillPressureStallAtom(std::vector<VendorAtomValue> *values) { + constexpr int avg_of_avg_offset = 2; + constexpr int total_start_idx = + PixelMmMetricsPerHour::kPsiCpuSomeTotalFieldNumber - kVendorAtomOffset; + constexpr int avg_start_idx = total_start_idx + kPsiNumAllTotals; + + if (!MmMetricsSupported()) + return; + + VendorAtomValue tmp; + + // The caller should have setup the correct total size, + // but we check and extend the size when it's too small for safety. + unsigned int min_value_size = total_start_idx + kPsiNumAllUploadMetrics; + if (values->size() < min_value_size) + values->resize(min_value_size); + + // "total" metric + int metric_idx = total_start_idx; + for (int save = 0; save < kPsiNumAllTotals; ++save, ++metric_idx) { + if (psi_data_set_count_ == 0) + psi_total_[save] = -1; // no data: invalidate the current total + + // A good difference needs a good previous value and a good current value. + if (psi_total_[save] != -1 && prev_psi_total_[save] != -1) + tmp.set<VendorAtomValue::longValue>(psi_total_[save] - prev_psi_total_[save]); + else + tmp.set<VendorAtomValue::longValue>(-1); + + prev_psi_total_[save] = psi_total_[save]; + if (metric_idx >= values->size()) { + // should never reach here + ALOGE("out of bound access to value[] for psi-total @ index %d", metric_idx); + goto cleanup; + } else { + (*values)[metric_idx] = tmp; + } + } + + // "avg" metrics -> aggregate to min, max, and avg of the original avg + metric_idx = avg_start_idx; + for (int save = 0; save < kPsiNumAllUploadAvgMetrics; ++save, ++metric_idx) { + if (psi_data_set_count_) { + if (save % kPsiNumOfAggregatedType == avg_of_avg_offset) { + // avg of avg + tmp.set<VendorAtomValue::intValue>(psi_aggregated_[save] / psi_data_set_count_); + } else { + // min or max of avg + tmp.set<VendorAtomValue::intValue>(psi_aggregated_[save]); + } + } else { + tmp.set<VendorAtomValue::intValue>(-1); + } + if (metric_idx >= values->size()) { + // should never reach here + ALOGE("out of bound access to value[] for psi-avg @ index %d", metric_idx); + goto cleanup; + } else { + (*values)[metric_idx] = tmp; + } + } + +cleanup: + psi_data_set_count_ = 0; +} + +/** * This function is to collect CMA metrics and upload them. * The CMA metrics are collected by readCmaStat(), copied into atom values * by fillAtomValues(), and then uploaded by reportVendorAtom(). The collected diff --git a/pixelstats/OWNERS b/pixelstats/OWNERS index c0767dda..124a755e 100644 --- a/pixelstats/OWNERS +++ b/pixelstats/OWNERS @@ -1,3 +1,5 @@ -tstrudel@google.com achant@google.com -per-file pixelatoms.proto = yro@google.com +apelosi@google.com +joaodias@google.com +stayfan@google.com +vincentwang@google.com diff --git a/pixelstats/OrientationCollector.cpp b/pixelstats/OrientationCollector.cpp deleted file mode 100644 index b33d3c68..00000000 --- a/pixelstats/OrientationCollector.cpp +++ /dev/null @@ -1,142 +0,0 @@ -/* - * Copyright (C) 2020 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-orientation" - -#include <android/sensor.h> -#include <log/log.h> -#include <pixelstats/OrientationCollector.h> - -namespace android { -namespace hardware { -namespace google { -namespace pixel { - -#define GET_EVENT_TIMEOUT_MILLIS 200 -#define SENSOR_TYPE_DEVICE_ORIENTATION 27 -#define ORIENTATION_UNKNOWN -1 - -sp<OrientationCollector> OrientationCollector::createOrientationCollector() { - sp<OrientationCollector> orientationCollector; - orientationCollector = new OrientationCollector(); - if (orientationCollector != nullptr && orientationCollector->init() < 0) { - orientationCollector->disableOrientationSensor(); - return nullptr; - } - return orientationCollector; -} - -/* pollOrientation - * orientation: [out] orientation value from sensor Hal. - * Return: OK, or error code from sensor Hal - */ -int32_t OrientationCollector::pollOrientation(int *orientation) { - int err = OK; - int eventCount = 0; - ASensorEvent sensorEvent; - - *orientation = ORIENTATION_UNKNOWN; - /* Get sensor events. */ - /* Get sensor sample events. */ - err = getEvents(&sensorEvent, 1, &eventCount); - if (eventCount > 0) { - ALOGV("%s: ##event data: %f,%f,%f", __func__, sensorEvent.data[0], sensorEvent.data[1], - sensorEvent.data[2]); - *orientation = sensorEvent.data[0]; - } - return err; -} - -/* - * Collects sensor samples and returns them in the sensor sample event list - * specified by event_list. Limits the number of returned sample events to the - * value specified by event_list_size. Returns the number of returned sample - * events in p_event_count. - * - * event_list List of collected sample events. - * event_list_size Size of sample event list. - * event_count Returned count of the number of collected sample - * events. - */ -int OrientationCollector::getEvents(ASensorEvent *event_list, size_t event_list_size, - int *event_count) { - int rv; - int err = OK; - - /* Wait for a sensor event to be available */ - /* The timeout is used to prevent blocking for long time, when sensor pool is - * empty, for example the device is put on a horizontal wireless charger. - */ - rv = ALooper_pollOnce(GET_EVENT_TIMEOUT_MILLIS, nullptr, nullptr, nullptr); - if (rv == ALOOPER_POLL_ERROR) { - ALOGI("Sensor event looper returned a poll error.\n"); - err = UNKNOWN_ERROR; - goto out; - } - - /* Get sensor events. */ - *event_count = ASensorEventQueue_getEvents(mQueue, event_list, event_list_size); - -out: - return err; -} - -int32_t OrientationCollector::init() { - int err = OK; - ALooper *looper = nullptr; - - // Get orientation sensor events from the NDK - mSensorManager = ASensorManager_getInstanceForPackage(nullptr); - if (mSensorManager == nullptr) { - ALOGE("%s: Unable to get sensorManager.\n", __func__); - return UNKNOWN_ERROR; - } - looper = ALooper_forThread(); - if (looper == nullptr) { - looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS); - } - if (looper == nullptr) { - ALOGE("%s: Failed to prepare an event looper.\n", __FUNCTION__); - return UNKNOWN_ERROR; - } - mQueue = ASensorManager_createEventQueue(mSensorManager, looper, 0, nullptr, nullptr); - mOrientationSensor = - ASensorManager_getDefaultSensor(mSensorManager, SENSOR_TYPE_DEVICE_ORIENTATION); - if (mOrientationSensor == nullptr) { - ALOGE("%s: Unable to get orientation sensor.\n", __func__); - return UNKNOWN_ERROR; - } - err = ASensorEventQueue_registerSensor(mQueue, mOrientationSensor, - ASensor_getMinDelay(mOrientationSensor), 0); - if (err < 0) { - ALOGE("%s: Unable to register for orientation sensor events\n", __func__); - } - return err; -} - -void OrientationCollector::disableOrientationSensor() { - if (mSensorManager != nullptr && mQueue != nullptr) { - if (mOrientationSensor != nullptr) { - ASensorEventQueue_disableSensor(mQueue, mOrientationSensor); - } - ASensorManager_destroyEventQueue(mSensorManager, mQueue); - } -} - -} // namespace pixel -} // namespace google -} // namespace hardware -} // namespace android diff --git a/pixelstats/PcaChargeStats.cpp b/pixelstats/PcaChargeStats.cpp index b81e4237..b0d97473 100644 --- a/pixelstats/PcaChargeStats.cpp +++ b/pixelstats/PcaChargeStats.cpp @@ -33,28 +33,40 @@ using android::base::ReadFileToString; using android::base::WriteStringToFile; bool PcaChargeStats::CheckPcaContentsAndAck(std::string *file_contents) { + std::string path = kPcaChargeMetricsPath; std::string line; std::istringstream ss; - if (!ReadFileToString(kPcaChargeMetricsPath.c_str(), file_contents)) { - return false; + if (!ReadFileToString(path.c_str(), file_contents)) { + if (!ReadFileToString(kPca94xxChargeMetricsPath.c_str(), file_contents)) { + path = kDcChargeMetricsPath; + } else { + path = kPca94xxChargeMetricsPath; + } + if (!ReadFileToString(path.c_str(), file_contents)) { + return false; + } } ss.str(*file_contents); if (!std::getline(ss, line)) { - ALOGE("Unable to read first line %s - %s", kPcaChargeMetricsPath.c_str(), strerror(errno)); + ALOGE("Unable to read first line %s - %s", path.c_str(), strerror(errno)); return false; } - if (!WriteStringToFile(std::to_string(0), kPcaChargeMetricsPath.c_str())) { - ALOGE("Couldn't clear %s - %s", kPcaChargeMetricsPath.c_str(), strerror(errno)); + if (!WriteStringToFile(std::to_string(0), path.c_str())) { + ALOGE("Couldn't clear %s - %s", path.c_str(), strerror(errno)); return false; } return true; } -PcaChargeStats::PcaChargeStats(const std::string pca_charge_metrics_path) - : kPcaChargeMetricsPath(pca_charge_metrics_path) {} +PcaChargeStats::PcaChargeStats(const std::string pca_charge_metrics_path, + const std::string pca94xx_charge_metrics_path, + const std::string dc_charge_metrics_path) + : kPcaChargeMetricsPath(pca_charge_metrics_path), + kPca94xxChargeMetricsPath(pca94xx_charge_metrics_path), + kDcChargeMetricsPath(dc_charge_metrics_path) {} } // namespace pixel } // namespace google diff --git a/pixelstats/SysfsCollector.cpp b/pixelstats/SysfsCollector.cpp index 14cba987..f4cef9bf 100644 --- a/pixelstats/SysfsCollector.cpp +++ b/pixelstats/SysfsCollector.cpp @@ -29,9 +29,14 @@ #include <mntent.h> #include <sys/timerfd.h> +#include <sys/vfs.h> #include <cinttypes> #include <string> +#ifndef ARRAY_SIZE +#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0])) +#endif + namespace android { namespace hardware { namespace google { @@ -43,18 +48,28 @@ using android::base::ReadFileToString; using android::base::StartsWith; using android::base::WriteStringToFile; using android::hardware::google::pixel::PixelAtoms::BatteryCapacity; +using android::hardware::google::pixel::PixelAtoms::BlockStatsReported; using android::hardware::google::pixel::PixelAtoms::BootStatsInfo; +using android::hardware::google::pixel::PixelAtoms::F2fsAtomicWriteInfo; using android::hardware::google::pixel::PixelAtoms::F2fsCompressionInfo; using android::hardware::google::pixel::PixelAtoms::F2fsGcSegmentInfo; +using android::hardware::google::pixel::PixelAtoms::F2fsSmartIdleMaintEnabledStateChanged; using android::hardware::google::pixel::PixelAtoms::F2fsStatsInfo; +using android::hardware::google::pixel::PixelAtoms::PartitionsUsedSpaceReported; +using android::hardware::google::pixel::PixelAtoms::PcieLinkStatsReported; using android::hardware::google::pixel::PixelAtoms::StorageUfsHealth; using android::hardware::google::pixel::PixelAtoms::StorageUfsResetCount; +using android::hardware::google::pixel::PixelAtoms::ThermalDfsStats; +using android::hardware::google::pixel::PixelAtoms::VendorAudioHardwareStatsReported; using android::hardware::google::pixel::PixelAtoms::VendorChargeCycles; using android::hardware::google::pixel::PixelAtoms::VendorHardwareFailed; +using android::hardware::google::pixel::PixelAtoms::VendorLongIRQStatsReported; +using android::hardware::google::pixel::PixelAtoms::VendorResumeLatencyStats; using android::hardware::google::pixel::PixelAtoms::VendorSlowIo; using android::hardware::google::pixel::PixelAtoms::VendorSpeakerImpedance; using android::hardware::google::pixel::PixelAtoms::VendorSpeakerStatsReported; using android::hardware::google::pixel::PixelAtoms::VendorSpeechDspStat; +using android::hardware::google::pixel::PixelAtoms::VendorTempResidencyStats; using android::hardware::google::pixel::PixelAtoms::ZramBdStat; using android::hardware::google::pixel::PixelAtoms::ZramMmStat; @@ -77,11 +92,22 @@ SysfsCollector::SysfsCollector(const struct SysfsPaths &sysfs_paths) kZramMmStatPath("/sys/block/zram0/mm_stat"), kZramBdStatPath("/sys/block/zram0/bd_stat"), kEEPROMPath(sysfs_paths.EEPROMPath), + kBrownoutLogPath(sysfs_paths.BrownoutLogPath), + kBrownoutReasonProp(sysfs_paths.BrownoutReasonProp), kPowerMitigationStatsPath(sysfs_paths.MitigationPath), kSpeakerTemperaturePath(sysfs_paths.SpeakerTemperaturePath), kSpeakerExcursionPath(sysfs_paths.SpeakerExcursionPath), kSpeakerHeartbeatPath(sysfs_paths.SpeakerHeartBeatPath), - kUFSErrStatsPath(sysfs_paths.UFSErrStatsPath) {} + kUFSErrStatsPath(sysfs_paths.UFSErrStatsPath), + kBlockStatsLength(sysfs_paths.BlockStatsLength), + kAmsRatePath(sysfs_paths.AmsRatePath), + kThermalStatsPaths(sysfs_paths.ThermalStatsPaths), + kCCARatePath(sysfs_paths.CCARatePath), + kTempResidencyAndResetPaths(sysfs_paths.TempResidencyAndResetPaths), + kLongIRQMetricsPath(sysfs_paths.LongIRQMetricsPath), + kResumeLatencyMetricsPath(sysfs_paths.ResumeLatencyMetricsPath), + kModemPcieLinkStatsPath(sysfs_paths.ModemPcieLinkStatsPath), + kWifiPcieLinkStatsPath(sysfs_paths.WifiPcieLinkStatsPath) {} bool SysfsCollector::ReadFileToInt(const std::string &path, int *val) { return ReadFileToInt(path.c_str(), val); @@ -285,85 +311,82 @@ void SysfsCollector::logSpeakerImpedance(const std::shared_ptr<IStats> &stats_cl * Report the last-detected impedance, temperature and heartbeats of left & right speakers. */ void SysfsCollector::logSpeakerHealthStats(const std::shared_ptr<IStats> &stats_client) { - std::string file_contents; + std::string file_contents_impedance; + std::string file_contents_temperature; + std::string file_contents_excursion; + std::string file_contents_heartbeat; + int count, i; + float impedance_ohm[4]; + float temperature_C[4]; + float excursion_mm[4]; + float heartbeat[4]; if (kImpedancePath == nullptr || strlen(kImpedancePath) == 0) { ALOGD("Audio impedance path not specified"); return; + } else if (!ReadFileToString(kImpedancePath, &file_contents_impedance)) { + ALOGD("Unable to read speaker impedance path %s", kImpedancePath); + return; } if (kSpeakerTemperaturePath == nullptr || strlen(kSpeakerTemperaturePath) == 0) { ALOGD("Audio speaker temperature path not specified"); return; - } - - if (kSpeakerHeartbeatPath == nullptr || strlen(kSpeakerHeartbeatPath) == 0) { - ALOGD("Audio speaker heartbeat path not specified"); + } else if (!ReadFileToString(kSpeakerTemperaturePath, &file_contents_temperature)) { + ALOGD("Unable to read speaker temperature path %s", kSpeakerTemperaturePath); return; } if (kSpeakerExcursionPath == nullptr || strlen(kSpeakerExcursionPath) == 0) { ALOGD("Audio speaker excursion path not specified"); return; - } - - float left_impedance_ohm, right_impedance_ohm; - - if (!ReadFileToString(kImpedancePath, &file_contents)) { - ALOGE("Unable to read speaker impedance path %s", kImpedancePath); - return; - } - if (sscanf(file_contents.c_str(), "%g,%g", &left_impedance_ohm, &right_impedance_ohm) != 2) { - ALOGE("Unable to parse speaker impedance %s", file_contents.c_str()); + } else if (!ReadFileToString(kSpeakerExcursionPath, &file_contents_excursion)) { + ALOGD("Unable to read speaker excursion path %s", kSpeakerExcursionPath); return; } - float left_temperature_C, right_temperature_C; - if (!ReadFileToString(kSpeakerTemperaturePath, &file_contents)) { - ALOGE("Unable to read speaker temperature path %s", kSpeakerTemperaturePath); + if (kSpeakerHeartbeatPath == nullptr || strlen(kSpeakerHeartbeatPath) == 0) { + ALOGD("Audio speaker heartbeat path not specified"); return; - } - if (sscanf(file_contents.c_str(), "%g,%g", &left_temperature_C, &right_temperature_C) != 2) { - ALOGE("Unable to parse speaker temperature %s", file_contents.c_str()); + } else if (!ReadFileToString(kSpeakerHeartbeatPath, &file_contents_heartbeat)) { + ALOGD("Unable to read speaker heartbeat path %s", kSpeakerHeartbeatPath); return; } - float left_excursion_mm, right_excursion_mm; - if (!ReadFileToString(kSpeakerExcursionPath, &file_contents)) { - ALOGE("Unable to read speaker excursion path %s", kSpeakerExcursionPath); + count = sscanf(file_contents_impedance.c_str(), "%g,%g,%g,%g", &impedance_ohm[0], + &impedance_ohm[1], &impedance_ohm[2], &impedance_ohm[3]); + if (count <= 0) return; - } - if (sscanf(file_contents.c_str(), "%g,%g", &left_excursion_mm, &right_excursion_mm) != 2) { - ALOGE("Unable to parse speaker excursion %s", file_contents.c_str()); + + count = sscanf(file_contents_temperature.c_str(), "%g,%g,%g,%g", &temperature_C[0], + &temperature_C[1], &temperature_C[2], &temperature_C[3]); + if (count <= 0) return; - } - float left_heartbeat, right_heartbeat; - if (!ReadFileToString(kSpeakerHeartbeatPath, &file_contents)) { - ALOGE("Unable to read speaker heartbeat path %s", kSpeakerHeartbeatPath); + count = sscanf(file_contents_excursion.c_str(), "%g,%g,%g,%g", &excursion_mm[0], + &excursion_mm[1], &excursion_mm[2], &excursion_mm[3]); + if (count <= 0) return; - } - if (sscanf(file_contents.c_str(), "%g,%g", &left_heartbeat, &right_heartbeat) != 2) { - ALOGE("Unable to parse speaker heartbeat %s", file_contents.c_str()); + + count = sscanf(file_contents_heartbeat.c_str(), "%g,%g,%g,%g", &heartbeat[0], &heartbeat[1], + &heartbeat[2], &heartbeat[3]); + if (count <= 0) return; - } - VendorSpeakerStatsReported left_obj; - left_obj.set_speaker_location(0); - left_obj.set_impedance(static_cast<int32_t>(left_impedance_ohm * 1000)); - left_obj.set_max_temperature(static_cast<int32_t>(left_temperature_C * 1000)); - left_obj.set_excursion(static_cast<int32_t>(left_excursion_mm * 1000)); - left_obj.set_heartbeat(static_cast<int32_t>(left_heartbeat)); + VendorSpeakerStatsReported obj[4]; + for (i = 0; i < count && i < 4; i++) { + obj[i].set_speaker_location(i); + obj[i].set_impedance(static_cast<int32_t>(impedance_ohm[i] * 1000)); + obj[i].set_max_temperature(static_cast<int32_t>(temperature_C[i] * 1000)); + obj[i].set_excursion(static_cast<int32_t>(excursion_mm[i] * 1000)); + obj[i].set_heartbeat(static_cast<int32_t>(heartbeat[i])); - VendorSpeakerStatsReported right_obj; - right_obj.set_speaker_location(1); - right_obj.set_impedance(static_cast<int32_t>(right_impedance_ohm * 1000)); - right_obj.set_max_temperature(static_cast<int32_t>(right_temperature_C * 1000)); - right_obj.set_excursion(static_cast<int32_t>(right_excursion_mm * 1000)); - right_obj.set_heartbeat(static_cast<int32_t>(right_heartbeat)); + reportSpeakerHealthStat(stats_client, obj[i]); + } +} - reportSpeakerHealthStat(stats_client, left_obj); - reportSpeakerHealthStat(stats_client, right_obj); +void SysfsCollector::logThermalStats(const std::shared_ptr<IStats> &stats_client) { + thermal_stats_reporter_.logThermalStats(stats_client, kThermalStatsPaths); } /** @@ -477,7 +500,7 @@ void SysfsCollector::logUFSErrorStats(const std::shared_ptr<IStats> &stats_clien int value, host_reset_count = 0; if (kUFSErrStatsPath.empty() || strlen(kUFSErrStatsPath.front().c_str()) == 0) { - ALOGV("UFS host reset count specified"); + ALOGV("UFS host reset count path not specified"); return; } @@ -601,6 +624,68 @@ void SysfsCollector::logF2fsStats(const std::shared_ptr<IStats> &stats_client) { } } +void SysfsCollector::logF2fsAtomicWriteInfo(const std::shared_ptr<IStats> &stats_client) { + int peak_atomic_write, committed_atomic_block, revoked_atomic_block; + + if (kF2fsStatsPath == nullptr) { + ALOGV("F2fs stats path not specified"); + return; + } + + std::string userdataBlock = getUserDataBlock(); + + std::string path = kF2fsStatsPath + (userdataBlock + "/peak_atomic_write"); + if (!ReadFileToInt(path, &peak_atomic_write)) { + ALOGE("Unable to read peak_atomic_write"); + return; + } else { + if (!WriteStringToFile(std::to_string(0), path)) { + ALOGE("Failed to write to file %s", path.c_str()); + return; + } + } + + path = kF2fsStatsPath + (userdataBlock + "/committed_atomic_block"); + if (!ReadFileToInt(path, &committed_atomic_block)) { + ALOGE("Unable to read committed_atomic_block"); + return; + } else { + if (!WriteStringToFile(std::to_string(0), path)) { + ALOGE("Failed to write to file %s", path.c_str()); + return; + } + } + + path = kF2fsStatsPath + (userdataBlock + "/revoked_atomic_block"); + if (!ReadFileToInt(path, &revoked_atomic_block)) { + ALOGE("Unable to read revoked_atomic_block"); + return; + } else { + if (!WriteStringToFile(std::to_string(0), path)) { + ALOGE("Failed to write to file %s", path.c_str()); + return; + } + } + + // Load values array + std::vector<VendorAtomValue> values(3); + values[F2fsAtomicWriteInfo::kPeakAtomicWriteFieldNumber - kVendorAtomOffset] = + VendorAtomValue::make<VendorAtomValue::intValue>(peak_atomic_write); + values[F2fsAtomicWriteInfo::kCommittedAtomicBlockFieldNumber - kVendorAtomOffset] = + VendorAtomValue::make<VendorAtomValue::intValue>(committed_atomic_block); + values[F2fsAtomicWriteInfo::kRevokedAtomicBlockFieldNumber - kVendorAtomOffset] = + VendorAtomValue::make<VendorAtomValue::intValue>(revoked_atomic_block); + + // Send vendor atom to IStats HAL + VendorAtom event = {.reverseDomainName = "", + .atomId = PixelAtoms::Atom::kF2FsAtomicWriteInfo, + .values = values}; + const ndk::ScopedAStatus ret = stats_client->reportVendorAtom(event); + if (!ret.isOk()) { + ALOGE("Unable to report F2fs Atomic Write info to Stats service"); + } +} + void SysfsCollector::logF2fsCompressionInfo(const std::shared_ptr<IStats> &stats_client) { int compr_written_blocks, compr_saved_blocks, compr_new_inodes; @@ -684,10 +769,12 @@ int SysfsCollector::getReclaimedSegments(const std::string &mode) { } void SysfsCollector::logF2fsGcSegmentInfo(const std::shared_ptr<IStats> &stats_client) { - int reclaimed_segments_normal, reclaimed_segments_urgent_high, reclaimed_segments_urgent_low; + int reclaimed_segments_normal, reclaimed_segments_urgent_high; + int reclaimed_segments_urgent_mid, reclaimed_segments_urgent_low; std::string gc_normal_mode = std::to_string(0); // GC normal mode std::string gc_urgent_high_mode = std::to_string(4); // GC urgent high mode std::string gc_urgent_low_mode = std::to_string(5); // GC urgent low mode + std::string gc_urgent_mid_mode = std::to_string(6); // GC urgent mid mode if (kF2fsStatsPath == nullptr) { ALOGV("F2fs stats path not specified"); @@ -700,9 +787,11 @@ void SysfsCollector::logF2fsGcSegmentInfo(const std::shared_ptr<IStats> &stats_c if (reclaimed_segments_urgent_high == -1) return; reclaimed_segments_urgent_low = getReclaimedSegments(gc_urgent_low_mode); if (reclaimed_segments_urgent_low == -1) return; + reclaimed_segments_urgent_mid = getReclaimedSegments(gc_urgent_mid_mode); + if (reclaimed_segments_urgent_mid == -1) return; // Load values array - std::vector<VendorAtomValue> values(3); + std::vector<VendorAtomValue> values(4); VendorAtomValue tmp; tmp.set<VendorAtomValue::intValue>(reclaimed_segments_normal); values[F2fsGcSegmentInfo::kReclaimedSegmentsNormalFieldNumber - kVendorAtomOffset] = tmp; @@ -710,6 +799,8 @@ void SysfsCollector::logF2fsGcSegmentInfo(const std::shared_ptr<IStats> &stats_c values[F2fsGcSegmentInfo::kReclaimedSegmentsUrgentHighFieldNumber - kVendorAtomOffset] = tmp; tmp.set<VendorAtomValue::intValue>(reclaimed_segments_urgent_low); values[F2fsGcSegmentInfo::kReclaimedSegmentsUrgentLowFieldNumber - kVendorAtomOffset] = tmp; + tmp.set<VendorAtomValue::intValue>(reclaimed_segments_urgent_mid); + values[F2fsGcSegmentInfo::kReclaimedSegmentsUrgentMidFieldNumber - kVendorAtomOffset] = tmp; // Send vendor atom to IStats HAL VendorAtom event = {.reverseDomainName = "", @@ -721,6 +812,96 @@ void SysfsCollector::logF2fsGcSegmentInfo(const std::shared_ptr<IStats> &stats_c } } +void SysfsCollector::logF2fsSmartIdleMaintEnabled(const std::shared_ptr<IStats> &stats_client) { + bool smart_idle_enabled = android::base::GetBoolProperty( + "persist.device_config.storage_native_boot.smart_idle_maint_enabled", false); + + // Load values array + VendorAtomValue tmp; + std::vector<VendorAtomValue> values(1); + tmp.set<VendorAtomValue::intValue>(smart_idle_enabled); + values[F2fsSmartIdleMaintEnabledStateChanged::kEnabledFieldNumber - kVendorAtomOffset] = tmp; + + // Send vendor atom to IStats HAL + VendorAtom event = {.reverseDomainName = PixelAtoms::ReverseDomainNames().pixel(), + .atomId = PixelAtoms::Atom::kF2FsSmartIdleMaintEnabledStateChanged, + .values = std::move(values)}; + const ndk::ScopedAStatus ret = stats_client->reportVendorAtom(event); + if (!ret.isOk()) { + ALOGE("Unable to report F2fsSmartIdleMaintEnabled to Stats service"); + } +} + +void SysfsCollector::logBlockStatsReported(const std::shared_ptr<IStats> &stats_client) { + std::string sdaPath = "/sys/block/sda/stat"; + std::string file_contents; + std::string stat; + std::vector<std::string> stats; + std::stringstream ss; + + // These index comes from kernel Document + // Documentation/ABI/stable/sysfs-block + const int READ_IO_IDX = 0, READ_SEC_IDX = 2, READ_TICK_IDX = 3; + const int WRITE_IO_IDX = 4, WRITE_SEC_IDX = 6, WRITE_TICK_IDX = 7; + uint64_t read_io, read_sectors, read_ticks; + uint64_t write_io, write_sectors, write_ticks; + + if (!ReadFileToString(sdaPath.c_str(), &file_contents)) { + ALOGE("Failed to read block layer stat %s", sdaPath.c_str()); + return; + } + + ss.str(file_contents); + while (ss >> stat) { + stats.push_back(stat); + } + + if (stats.size() < kBlockStatsLength) { + ALOGE("block layer stat format is incorrect %s, length %zu/%d", file_contents.c_str(), + stats.size(), kBlockStatsLength); + return; + } + + read_io = std::stoul(stats[READ_IO_IDX]); + read_sectors = std::stoul(stats[READ_SEC_IDX]); + read_ticks = std::stoul(stats[READ_TICK_IDX]); + write_io = std::stoul(stats[WRITE_IO_IDX]); + write_sectors = std::stoul(stats[WRITE_SEC_IDX]); + write_ticks = std::stoul(stats[WRITE_TICK_IDX]); + + // Load values array + std::vector<VendorAtomValue> values(6); + values[BlockStatsReported::kReadIoFieldNumber - kVendorAtomOffset] = + VendorAtomValue::make<VendorAtomValue::longValue>(read_io); + values[BlockStatsReported::kReadSectorsFieldNumber - kVendorAtomOffset] = + VendorAtomValue::make<VendorAtomValue::longValue>(read_sectors); + values[BlockStatsReported::kReadTicksFieldNumber - kVendorAtomOffset] = + VendorAtomValue::make<VendorAtomValue::longValue>(read_ticks); + values[BlockStatsReported::kWriteIoFieldNumber - kVendorAtomOffset] = + VendorAtomValue::make<VendorAtomValue::longValue>(write_io); + values[BlockStatsReported::kWriteSectorsFieldNumber - kVendorAtomOffset] = + VendorAtomValue::make<VendorAtomValue::longValue>(write_sectors); + values[BlockStatsReported::kWriteTicksFieldNumber - kVendorAtomOffset] = + VendorAtomValue::make<VendorAtomValue::longValue>(write_ticks); + + // Send vendor atom to IStats HAL + VendorAtom event = {.reverseDomainName = PixelAtoms::ReverseDomainNames().pixel(), + .atomId = PixelAtoms::Atom::kBlockStatsReported, + .values = std::move(values)}; + const ndk::ScopedAStatus ret = stats_client->reportVendorAtom(event); + if (!ret.isOk()) { + ALOGE("Unable to report block layer stats to Stats service"); + } +} + +void SysfsCollector::logTempResidencyStats(const std::shared_ptr<IStats> &stats_client) { + for (const auto &temp_residency_and_reset_path : kTempResidencyAndResetPaths) { + temp_residency_reporter_.logTempResidencyStats(stats_client, + temp_residency_and_reset_path.first, + temp_residency_and_reset_path.second); + } +} + void SysfsCollector::reportZramMmStat(const std::shared_ptr<IStats> &stats_client) { std::string file_contents; if (!kZramMmStatPath) { @@ -878,6 +1059,457 @@ void SysfsCollector::logBootStats(const std::shared_ptr<IStats> &stats_client) { } } +/** + * Report the AMS & CCA rate. + */ +void SysfsCollector::logVendorAudioHardwareStats(const std::shared_ptr<IStats> &stats_client) { + std::string file_contents; + uint32_t milli_ams_rate, cca_active_rate, cca_enable_rate; + bool isAmsReady = false, isCCAReady = false; + + if (kAmsRatePath == nullptr) { + ALOGD("Audio AMS Rate path not specified"); + } else { + if (!ReadFileToString(kAmsRatePath, &file_contents)) { + ALOGD("Unable to read ams_rate path %s", kAmsRatePath); + } else { + if (sscanf(file_contents.c_str(), "%u", &milli_ams_rate) != 1) { + ALOGD("Unable to parse ams_rate %s", file_contents.c_str()); + } else { + isAmsReady = true; + ALOGD("milli_ams_rate = %u", milli_ams_rate); + } + } + } + + if (kCCARatePath == nullptr) { + ALOGD("Audio CCA Rate path not specified"); + } else { + if (!ReadFileToString(kCCARatePath, &file_contents)) { + ALOGD("Unable to read cca_rate path %s", kCCARatePath); + } else { + if (sscanf(file_contents.c_str(), "%u,%u", &cca_active_rate, &cca_enable_rate) != 2) { + ALOGD("Unable to parse cca rates %s", file_contents.c_str()); + } else { + isCCAReady = true; + ALOGD("cca_active_rate = %u, cca_enable_rate = %u", cca_active_rate, + cca_enable_rate); + } + } + } + + if (!(isAmsReady || isCCAReady)) { + ALOGD("no ams or cca data to report"); + return; + } + + std::vector<VendorAtomValue> values(3); + VendorAtomValue tmp; + + if (isAmsReady) { + tmp.set<VendorAtomValue::intValue>(milli_ams_rate); + values[VendorAudioHardwareStatsReported::kMilliRateOfAmsPerDayFieldNumber - + kVendorAtomOffset] = tmp; + } + + if (isCCAReady) { + tmp.set<VendorAtomValue::intValue>(cca_active_rate); + values[VendorAudioHardwareStatsReported::kRateOfCcaActivePerDayFieldNumber - + kVendorAtomOffset] = tmp; + + tmp.set<VendorAtomValue::intValue>(cca_enable_rate); + values[VendorAudioHardwareStatsReported::kRateOfCcaEnablePerDayFieldNumber - + kVendorAtomOffset] = tmp; + } + + // Send vendor atom to IStats HAL + VendorAtom event = {.reverseDomainName = "", + .atomId = PixelAtoms::Atom::kVendorAudioHardwareStatsReported, + .values = std::move(values)}; + + const ndk::ScopedAStatus ret = stats_client->reportVendorAtom(event); + if (!ret.isOk()) + ALOGE("Unable to report VendorAudioHardwareStatsReported to Stats service"); +} + +/** + * Logs the Resume Latency stats. + */ +void SysfsCollector::logVendorResumeLatencyStats(const std::shared_ptr<IStats> &stats_client) { + std::string uart_enabled = android::base::GetProperty("init.svc.console", ""); + if (uart_enabled == "running") { + return; + } + std::string file_contents; + if (!kResumeLatencyMetricsPath) { + ALOGE("ResumeLatencyMetrics path not specified"); + return; + } + if (!ReadFileToString(kResumeLatencyMetricsPath, &file_contents)) { + ALOGE("Unable to ResumeLatencyMetric %s - %s", kResumeLatencyMetricsPath, strerror(errno)); + return; + } + + int offset = 0; + int bytes_read; + const char *data = file_contents.c_str(); + int data_len = file_contents.length(); + + int curr_bucket_cnt; + if (!sscanf(data + offset, "Resume Latency Bucket Count: %d\n%n", &curr_bucket_cnt, + &bytes_read)) + return; + offset += bytes_read; + if (offset >= data_len) + return; + + int64_t max_latency; + if (!sscanf(data + offset, "Max Resume Latency: %" PRId64 "\n%n", &max_latency, &bytes_read)) + return; + offset += bytes_read; + if (offset >= data_len) + return; + + uint64_t sum_latency; + if (!sscanf(data + offset, "Sum Resume Latency: %" PRIu64 "\n%n", &sum_latency, &bytes_read)) + return; + offset += bytes_read; + if (offset >= data_len) + return; + + if (curr_bucket_cnt > kMaxResumeLatencyBuckets) + return; + if (curr_bucket_cnt != prev_data.bucket_cnt) { + prev_data.resume_latency_buckets.clear(); + } + + int64_t total_latency_cnt = 0; + int64_t count; + int index = 2; + std::vector<VendorAtomValue> values(curr_bucket_cnt + 2); + VendorAtomValue tmp; + // Iterate over resume latency buckets to get latency count within some latency thresholds + while (sscanf(data + offset, "%*ld - %*ldms ====> %" PRId64 "\n%n", &count, &bytes_read) == 1 || + sscanf(data + offset, "%*ld - infms ====> %" PRId64 "\n%n", &count, &bytes_read) == 1) { + offset += bytes_read; + if (offset >= data_len && (index + 1 < curr_bucket_cnt + 2)) + return; + if (curr_bucket_cnt == prev_data.bucket_cnt) { + tmp.set<VendorAtomValue::longValue>(count - + prev_data.resume_latency_buckets[index - 2]); + prev_data.resume_latency_buckets[index - 2] = count; + } else { + tmp.set<VendorAtomValue::longValue>(count); + prev_data.resume_latency_buckets.push_back(count); + } + if (index >= curr_bucket_cnt + 2) + return; + values[index] = tmp; + index += 1; + total_latency_cnt += count; + } + tmp.set<VendorAtomValue::longValue>(max_latency); + values[0] = tmp; + if ((sum_latency - prev_data.resume_latency_sum_ms < 0) || + (total_latency_cnt - prev_data.resume_count <= 0)) { + tmp.set<VendorAtomValue::longValue>(-1); + ALOGI("average resume latency get overflow"); + } else { + tmp.set<VendorAtomValue::longValue>( + (int64_t)(sum_latency - prev_data.resume_latency_sum_ms) / + (total_latency_cnt - prev_data.resume_count)); + } + values[1] = tmp; + + prev_data.resume_latency_sum_ms = sum_latency; + prev_data.resume_count = total_latency_cnt; + prev_data.bucket_cnt = curr_bucket_cnt; + // Send vendor atom to IStats HAL + VendorAtom event = {.reverseDomainName = "", + .atomId = PixelAtoms::Atom::kVendorResumeLatencyStats, + .values = std::move(values)}; + const ndk::ScopedAStatus ret = stats_client->reportVendorAtom(event); + if (!ret.isOk()) + ALOGE("Unable to report VendorResumeLatencyStats to Stats service"); +} + +bool cmp(const std::pair<int, int64_t> &a, const std::pair<int, int64_t> &b) { + return a.second > b.second; +} + +/** + * Sort irq stats by irq latency, and load top 5 irq stats. + */ +void process_irqatom_values(std::vector<std::pair<int, int64_t>> sorted_pair, + std::vector<VendorAtomValue> *values) { + VendorAtomValue tmp; + sort(sorted_pair.begin(), sorted_pair.end(), cmp); + int irq_stats_size = sorted_pair.size(); + for (int i = 0; i < 5; i++) { + if (irq_stats_size < 5 && i >= irq_stats_size) { + tmp.set<VendorAtomValue::longValue>(-1); + values->push_back(tmp); + tmp.set<VendorAtomValue::longValue>(0); + values->push_back(tmp); + } else { + tmp.set<VendorAtomValue::longValue>(sorted_pair[i].first); + values->push_back(tmp); + tmp.set<VendorAtomValue::longValue>(sorted_pair[i].second); + values->push_back(tmp); + } + } +} + +/** + * Logs the Long irq stats. + */ +void SysfsCollector::logVendorLongIRQStatsReported(const std::shared_ptr<IStats> &stats_client) { + std::string uart_enabled = android::base::GetProperty("init.svc.console", ""); + if (uart_enabled == "running") { + return; + } + std::string file_contents; + if (!kLongIRQMetricsPath) { + ALOGV("LongIRQ path not specified"); + return; + } + if (!ReadFileToString(kLongIRQMetricsPath, &file_contents)) { + ALOGE("Unable to LongIRQ %s - %s", kLongIRQMetricsPath, strerror(errno)); + return; + } + int offset = 0; + int bytes_read; + const char *data = file_contents.c_str(); + int data_len = file_contents.length(); + // Get, process, store softirq stats + std::vector<std::pair<int, int64_t>> sorted_softirq_pair; + int64_t softirq_count; + if (sscanf(data + offset, "long SOFTIRQ count: %" PRId64 "\n%n", &softirq_count, &bytes_read) != + 1) + return; + offset += bytes_read; + if (offset >= data_len) + return; + std::vector<VendorAtomValue> values; + VendorAtomValue tmp; + if (softirq_count - prev_data.softirq_count < 0) { + tmp.set<VendorAtomValue::intValue>(-1); + ALOGI("long softirq count get overflow"); + } else { + tmp.set<VendorAtomValue::longValue>(softirq_count - prev_data.softirq_count); + } + values.push_back(tmp); + + if (sscanf(data + offset, "long SOFTIRQ detail (num, latency):\n%n", &bytes_read) != 0) + return; + offset += bytes_read; + if (offset >= data_len) + return; + + // Iterate over softirq stats and record top 5 long softirq + int64_t softirq_latency; + int softirq_num; + while (sscanf(data + offset, "%d %" PRId64 "\n%n", &softirq_num, &softirq_latency, + &bytes_read) == 2) { + sorted_softirq_pair.push_back(std::make_pair(softirq_num, softirq_latency)); + offset += bytes_read; + if (offset >= data_len) + return; + } + process_irqatom_values(sorted_softirq_pair, &values); + + // Get, process, store irq stats + std::vector<std::pair<int, int64_t>> sorted_irq_pair; + int64_t irq_count; + if (sscanf(data + offset, "long IRQ count: %" PRId64 "\n%n", &irq_count, &bytes_read) != 1) + return; + offset += bytes_read; + if (offset >= data_len) + return; + if (irq_count - prev_data.irq_count < 0) { + tmp.set<VendorAtomValue::intValue>(-1); + ALOGI("long irq count get overflow"); + } else { + tmp.set<VendorAtomValue::longValue>(irq_count - prev_data.irq_count); + } + values.push_back(tmp); + + if (sscanf(data + offset, "long IRQ detail (num, latency):\n%n", &bytes_read) != 0) + return; + offset += bytes_read; + if (offset >= data_len) + return; + + int64_t irq_latency; + int irq_num; + int index = 0; + // Iterate over softirq stats and record top 5 long irq + while (sscanf(data + offset, "%d %" PRId64 "\n%n", &irq_num, &irq_latency, &bytes_read) == 2) { + sorted_irq_pair.push_back(std::make_pair(irq_num, irq_latency)); + offset += bytes_read; + if (offset >= data_len && index < 5) + return; + index += 1; + } + process_irqatom_values(sorted_irq_pair, &values); + + prev_data.softirq_count = softirq_count; + prev_data.irq_count = irq_count; + // Send vendor atom to IStats HAL + VendorAtom event = {.reverseDomainName = "", + .atomId = PixelAtoms::Atom::kVendorLongIrqStatsReported, + .values = std::move(values)}; + const ndk::ScopedAStatus ret = stats_client->reportVendorAtom(event); + if (!ret.isOk()) + ALOGE("Unable to report kVendorLongIRQStatsReported to Stats service"); +} + +void SysfsCollector::logPartitionUsedSpace(const std::shared_ptr<IStats> &stats_client) { + struct statfs fs_info; + char path[] = "/mnt/vendor/persist"; + + if (statfs(path, &fs_info) == -1) { + ALOGE("statfs: %s", strerror(errno)); + return; + } + + // Load values array + std::vector<VendorAtomValue> values(3); + values[PartitionsUsedSpaceReported::kDirectoryFieldNumber - kVendorAtomOffset] = + VendorAtomValue::make<VendorAtomValue::intValue> + (PixelAtoms::PartitionsUsedSpaceReported::PERSIST); + values[PartitionsUsedSpaceReported::kFreeBytesFieldNumber - kVendorAtomOffset] = + VendorAtomValue::make<VendorAtomValue::longValue>(fs_info.f_bsize * fs_info.f_bfree); + values[PartitionsUsedSpaceReported::kTotalBytesFieldNumber - kVendorAtomOffset] = + VendorAtomValue::make<VendorAtomValue::longValue>(fs_info.f_bsize * fs_info.f_blocks); + // Send vendor atom to IStats HAL + VendorAtom event = {.reverseDomainName = "", + .atomId = PixelAtoms::Atom::kPartitionUsedSpaceReported, + .values = std::move(values)}; + + const ndk::ScopedAStatus ret = stats_client->reportVendorAtom(event); + if (!ret.isOk()) { + ALOGE("Unable to report Partitions Used Space Reported to stats service"); + } +} + +void SysfsCollector::logPcieLinkStats(const std::shared_ptr<IStats> &stats_client) { + struct sysfs_map { + const char *sysfs_path; + bool is_counter; + int modem_val; + int wifi_val; + int modem_msg_field_number; + int wifi_msg_field_number; + }; + + int i; + bool reportPcieLinkStats = false; + + /* Map sysfs data to PcieLinkStatsReported message elements */ + struct sysfs_map datamap[] = { + {"link_down_irqs", true, 0, 0, + PcieLinkStatsReported::kModemPcieLinkdownsFieldNumber, + PcieLinkStatsReported::kWifiPcieLinkdownsFieldNumber}, + + {"complete_timeout_irqs", true, 0, 0, + PcieLinkStatsReported::kModemPcieCompletionTimeoutsFieldNumber, + PcieLinkStatsReported::kWifiPcieCompletionTimeoutsFieldNumber}, + + {"link_up_failures", true, 0, 0, + PcieLinkStatsReported::kModemPcieLinkupFailuresFieldNumber, + PcieLinkStatsReported::kWifiPcieLinkupFailuresFieldNumber}, + + {"link_recovery_failures", true, 0, 0, + PcieLinkStatsReported::kModemPcieLinkRecoveryFailuresFieldNumber, + PcieLinkStatsReported::kWifiPcieLinkRecoveryFailuresFieldNumber}, + + {"pll_lock_average", false, 0, 0, + PcieLinkStatsReported::kModemPciePllLockAvgFieldNumber, + PcieLinkStatsReported::kWifiPciePllLockAvgFieldNumber}, + + {"link_up_average", false, 0, 0, + PcieLinkStatsReported::kModemPcieLinkUpAvgFieldNumber, + PcieLinkStatsReported::kWifiPcieLinkUpAvgFieldNumber }, + }; + + + if (kModemPcieLinkStatsPath == nullptr) { + ALOGD("Modem PCIe stats path not specified"); + } else { + for (i=0; i < ARRAY_SIZE(datamap); i++) { + std::string modempath = + std::string(kModemPcieLinkStatsPath) + "/" + datamap[i].sysfs_path; + + if (ReadFileToInt(modempath, &(datamap[i].modem_val))) { + reportPcieLinkStats = true; + ALOGD("Modem %s = %d", datamap[i].sysfs_path, + datamap[i].modem_val); + if (datamap[i].is_counter) { + std::string value = std::to_string(datamap[i].modem_val); + /* Writing the value back clears the counter */ + if (!WriteStringToFile(value, modempath)) { + ALOGE("Unable to clear modem PCIe statistics file: %s - %s", + modempath.c_str(), strerror(errno)); + } + } + } + } + } + + if (kWifiPcieLinkStatsPath == nullptr) { + ALOGD("Wifi PCIe stats path not specified"); + } else { + for (i=0; i < ARRAY_SIZE(datamap); i++) { + std::string wifipath = + std::string(kWifiPcieLinkStatsPath) + "/" + datamap[i].sysfs_path; + + if (ReadFileToInt(wifipath, &(datamap[i].wifi_val))) { + reportPcieLinkStats = true; + ALOGD("Wifi %s = %d", datamap[i].sysfs_path, + datamap[i].wifi_val); + if (datamap[i].is_counter) { + std::string value = std::to_string(datamap[i].wifi_val); + /* Writing the value back clears the counter */ + if (!WriteStringToFile(value, wifipath)) { + ALOGE("Unable to clear wifi PCIe statistics file: %s - %s", + wifipath.c_str(), strerror(errno)); + } + } + } + } + } + + if (!reportPcieLinkStats) { + ALOGD("No PCIe link stats to report"); + return; + } + + // Load values array + std::vector<VendorAtomValue> values(2 * ARRAY_SIZE(datamap)); + VendorAtomValue tmp; + for (i=0; i < ARRAY_SIZE(datamap); i++) { + if (datamap[i].modem_val > 0) { + tmp.set<VendorAtomValue::intValue>(datamap[i].modem_val); + values[datamap[i].modem_msg_field_number - kVendorAtomOffset] = tmp; + } + if (datamap[i].wifi_val > 0) { + tmp.set<VendorAtomValue::intValue>(datamap[i].wifi_val); + values[datamap[i].wifi_msg_field_number - kVendorAtomOffset] = tmp; + } + } + + // Send vendor atom to IStats HAL + VendorAtom event = {.reverseDomainName = "", + .atomId = PixelAtoms::Atom::kPcieLinkStats, + .values = std::move(values)}; + + const ndk::ScopedAStatus ret = stats_client->reportVendorAtom(event); + if (!ret.isOk()) { + ALOGE("Unable to report PCIe link statistics to stats service"); + } +} + void SysfsCollector::logPerDay() { const std::shared_ptr<IStats> stats_client = getStatsService(); if (!stats_client) { @@ -892,11 +1524,14 @@ void SysfsCollector::logPerDay() { logBatteryChargeCycles(stats_client); logBatteryEEPROM(stats_client); logBatteryHealth(stats_client); + logBlockStatsReported(stats_client); logCodec1Failed(stats_client); logCodecFailed(stats_client); logF2fsStats(stats_client); + logF2fsAtomicWriteInfo(stats_client); logF2fsCompressionInfo(stats_client); logF2fsGcSegmentInfo(stats_client); + logF2fsSmartIdleMaintEnabled(stats_client); logSlowIO(stats_client); logSpeakerImpedance(stats_client); logSpeechDspStat(stats_client); @@ -905,6 +1540,32 @@ void SysfsCollector::logPerDay() { logSpeakerHealthStats(stats_client); mm_metrics_reporter_.logCmaStatus(stats_client); mm_metrics_reporter_.logPixelMmMetricsPerDay(stats_client); + logVendorAudioHardwareStats(stats_client); + logThermalStats(stats_client); + logTempResidencyStats(stats_client); + logVendorLongIRQStatsReported(stats_client); + logVendorResumeLatencyStats(stats_client); + logPartitionUsedSpace(stats_client); + logPcieLinkStats(stats_client); +} + +void SysfsCollector::aggregatePer5Min() { + mm_metrics_reporter_.aggregatePixelMmMetricsPer5Min(); +} + +void SysfsCollector::logBrownout() { + const std::shared_ptr<IStats> stats_client = getStatsService(); + if (!stats_client) { + ALOGE("Unable to get AIDL Stats service"); + return; + } + if (kBrownoutLogPath != nullptr && strlen(kBrownoutLogPath) > 0) + brownout_detected_reporter_.logBrownout(stats_client, kBrownoutLogPath, + kBrownoutReasonProp); +} + +void SysfsCollector::logOnce() { + logBrownout(); } void SysfsCollector::logPerHour() { @@ -934,17 +1595,30 @@ void SysfsCollector::collect(void) { // Sleep for 30 seconds on launch to allow codec driver to load. sleep(30); + // sample & aggregate for the first time. + aggregatePer5Min(); + // Collect first set of stats on boot. + logOnce(); logPerHour(); logPerDay(); - // Set an one-hour timer. struct itimerspec period; - const int kSecondsPerHour = 60 * 60; - int hours = 0; - period.it_interval.tv_sec = kSecondsPerHour; + + // gcd (greatest common divisor) of all the following timings + constexpr int kSecondsPerWake = 5 * 60; + + constexpr int kWakesPer5Min = 5 * 60 / kSecondsPerWake; + constexpr int kWakesPerHour = 60 * 60 / kSecondsPerWake; + constexpr int kWakesPerDay = 24 * 60 * 60 / kSecondsPerWake; + + int wake_5min = 0; + int wake_hours = 0; + int wake_days = 0; + + period.it_interval.tv_sec = kSecondsPerWake; period.it_interval.tv_nsec = 0; - period.it_value.tv_sec = kSecondsPerHour; + period.it_value.tv_sec = kSecondsPerWake; period.it_value.tv_nsec = 0; if (timerfd_settime(timerfd, 0, &period, NULL)) { @@ -954,22 +1628,41 @@ void SysfsCollector::collect(void) { while (1) { int readval; - do { + union { char buf[8]; + uint64_t count; + } expire; + + do { errno = 0; - readval = read(timerfd, buf, sizeof(buf)); + readval = read(timerfd, expire.buf, sizeof(expire.buf)); } while (readval < 0 && errno == EINTR); if (readval < 0) { ALOGE("Timerfd error - %s\n", strerror(errno)); return; } - hours++; - logPerHour(); - if (hours == 24) { - // Collect stats every 24hrs after. + wake_5min += expire.count; + wake_hours += expire.count; + wake_days += expire.count; + + if (wake_5min >= kWakesPer5Min) { + wake_5min %= kWakesPer5Min; + aggregatePer5Min(); + } + + if (wake_hours >= kWakesPerHour) { + if (wake_hours >= 2 * kWakesPerHour) + ALOGW("Hourly wake: sleep too much: expire.count=%" PRId64, expire.count); + wake_hours %= kWakesPerHour; + logPerHour(); + } + + if (wake_days >= kWakesPerDay) { + if (wake_hours >= 2 * kWakesPerDay) + ALOGW("Daily wake: sleep too much: expire.count=%" PRId64, expire.count); + wake_days %= kWakesPerDay; logPerDay(); - hours = 0; } } } diff --git a/pixelstats/TempResidencyReporter.cpp b/pixelstats/TempResidencyReporter.cpp new file mode 100644 index 00000000..254d9ee9 --- /dev/null +++ b/pixelstats/TempResidencyReporter.cpp @@ -0,0 +1,201 @@ +/* + * 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: TempResidencyStats" + +#include <aidl/android/frameworks/stats/IStats.h> +#include <android-base/chrono_utils.h> +#include <android-base/file.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/TempResidencyReporter.h> +#include <utils/Log.h> + +#include <cinttypes> + +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::base::WriteStringToFile; +using android::hardware::google::pixel::PixelAtoms::ThermalDfsStats; + +bool updateOffsetAndCheckBound(int *offset, const int &bytes_read, const int &data_len) { + *offset += bytes_read; + return *offset <= data_len; +} + +/** + * Parse file_contents and read residency stats into stats. + */ +bool parse_file_contents(std::string file_contents, + std::map<std::string, TempResidencyStats> *stats) { + const char *data = file_contents.c_str(); + int data_len = file_contents.length(); + char sensor_name[32]; + int offset = 0; + int bytes_read; + + while (sscanf(data + offset, "THERMAL ZONE: %31s\n%n", sensor_name, &bytes_read) == 1) { + TempResidencyStats temp_residency_stats; + int64_t temp_res_value; + int num_stats_buckets; + int index = 0; + if (!updateOffsetAndCheckBound(&offset, bytes_read, data_len)) + return false; + + std::string sensor_name_str = sensor_name; + + if (!sscanf(data + offset, "MAX_TEMP: %f\n%n", &temp_residency_stats.max_temp, + &bytes_read) || + !updateOffsetAndCheckBound(&offset, bytes_read, data_len)) + return false; + + if (!sscanf(data + offset, "MAX_TEMP_TIMESTAMP: %" PRId64 "s\n%n", + &temp_residency_stats.max_temp_timestamp, &bytes_read) || + !updateOffsetAndCheckBound(&offset, bytes_read, data_len)) + return false; + + if (!sscanf(data + offset, "MIN_TEMP: %f\n%n", &temp_residency_stats.min_temp, + &bytes_read) || + !updateOffsetAndCheckBound(&offset, bytes_read, data_len)) + return false; + + if (!sscanf(data + offset, "MIN_TEMP_TIMESTAMP: %" PRId64 "s\n%n", + &temp_residency_stats.min_temp_timestamp, &bytes_read) || + !updateOffsetAndCheckBound(&offset, bytes_read, data_len)) + return false; + + if (!sscanf(data + offset, "NUM_TEMP_RESIDENCY_BUCKETS: %d\n%n", &num_stats_buckets, + &bytes_read) || + !updateOffsetAndCheckBound(&offset, bytes_read, data_len)) + return false; + + while (index < num_stats_buckets) { + if (sscanf(data + offset, "-inf - %*d ====> %" PRId64 "ms\n%n", &temp_res_value, + &bytes_read) != 1 && + sscanf(data + offset, "%*d - %*d ====> %" PRId64 "ms\n%n", &temp_res_value, + &bytes_read) != 1 && + sscanf(data + offset, "%*d - inf ====> %" PRId64 "ms\n\n%n", &temp_res_value, + &bytes_read) != 1) + return false; + + temp_residency_stats.temp_residency_buckets.push_back(temp_res_value); + index++; + + offset += bytes_read; + if ((offset >= data_len) && (index < num_stats_buckets)) + return false; + } + (*stats)[sensor_name_str] = temp_residency_stats; + } + return true; +} + +/** + * Logs the Temperature residency stats for every thermal zone. + */ +void TempResidencyReporter::logTempResidencyStats( + const std::shared_ptr<IStats> &stats_client, std::string_view temperature_residency_path, + std::string_view temperature_residency_reset_path) { + if (temperature_residency_path.empty() || temperature_residency_reset_path.empty()) { + ALOGV("TempResidency Stats/Reset path not specified"); + return; + } + std::string file_contents; + if (!ReadFileToString(temperature_residency_path.data(), &file_contents)) { + ALOGE("Unable to read TempResidencyStatsPath"); + return; + } + std::map<std::string, TempResidencyStats> stats_map; + if (!parse_file_contents(file_contents, &stats_map)) { + ALOGE("Fail to parse TempResidencyStatsPath"); + return; + } + if (!stats_map.size()) + return; + ::android::base::boot_clock::time_point curTime = ::android::base::boot_clock::now(); + int64_t since_last_update_ms = + std::chrono::duration_cast<std::chrono::milliseconds>(curTime - prevTime).count(); + + // Reset the stats for next day collection and if failed return without reporting to report the + // combined residency next day. + if (!WriteStringToFile(std::to_string(1), temperature_residency_reset_path.data())) { + ALOGE("Failed to reset TempResidencyStats"); + return; + } + + auto stats_map_iterator = stats_map.begin(); + VendorAtomValue tmp_atom_value; + + // Iterate through stats_map by sensor_name + while (stats_map_iterator != stats_map.end()) { + std::vector<VendorAtomValue> values; + const auto &sensor_name_str = stats_map_iterator->first; + const auto &temp_residency_stats = stats_map_iterator->second; + const auto &temp_residency_buckets_count = + temp_residency_stats.temp_residency_buckets.size(); + if (temp_residency_buckets_count > kMaxBucketLen) { + stats_map_iterator++; + continue; + } + tmp_atom_value.set<VendorAtomValue::stringValue>(sensor_name_str); + values.push_back(tmp_atom_value); + tmp_atom_value.set<VendorAtomValue::longValue>(since_last_update_ms); + values.push_back(tmp_atom_value); + // Iterate over every temperature residency buckets + for (const auto &temp_residency_bucket : temp_residency_stats.temp_residency_buckets) { + tmp_atom_value.set<VendorAtomValue::longValue>(temp_residency_bucket); + values.push_back(tmp_atom_value); + } + // Fill the remaining residency buckets with 0. + int remaining_residency_buckets_count = kMaxBucketLen - temp_residency_buckets_count; + if (remaining_residency_buckets_count > 0) { + tmp_atom_value.set<VendorAtomValue::longValue>(0); + values.insert(values.end(), remaining_residency_buckets_count, tmp_atom_value); + } + tmp_atom_value.set<VendorAtomValue::floatValue>(temp_residency_stats.max_temp); + values.push_back(tmp_atom_value); + tmp_atom_value.set<VendorAtomValue::longValue>(temp_residency_stats.max_temp_timestamp); + values.push_back(tmp_atom_value); + tmp_atom_value.set<VendorAtomValue::floatValue>(temp_residency_stats.min_temp); + values.push_back(tmp_atom_value); + tmp_atom_value.set<VendorAtomValue::longValue>(temp_residency_stats.min_temp_timestamp); + values.push_back(tmp_atom_value); + // Send vendor atom to IStats HAL + VendorAtom event = {.reverseDomainName = "", + .atomId = PixelAtoms::Atom::kVendorTempResidencyStats, + .values = std::move(values)}; + ndk::ScopedAStatus ret = stats_client->reportVendorAtom(event); + if (!ret.isOk()) + ALOGE("Unable to report VendorTempResidencyStats to Stats service"); + + stats_map_iterator++; + } + prevTime = curTime; +} + +} // namespace pixel +} // namespace google +} // namespace hardware +} // namespace android diff --git a/pixelstats/ThermalStatsReporter.cpp b/pixelstats/ThermalStatsReporter.cpp new file mode 100644 index 00000000..d0e7db41 --- /dev/null +++ b/pixelstats/ThermalStatsReporter.cpp @@ -0,0 +1,190 @@ +/* + * 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: ThermalStats" + +#include <aidl/android/frameworks/stats/IStats.h> +#include <android-base/file.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/ThermalStatsReporter.h> +#include <utils/Log.h> + +#include <cinttypes> + +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::ThermalDfsStats; + +ThermalStatsReporter::ThermalStatsReporter() {} + +bool ThermalStatsReporter::readDfsCount(const std::string &path, int64_t *val) { + std::string file_contents; + + if (path.empty()) { + ALOGE("Empty path"); + return false; + } + + if (!ReadFileToString(path.c_str(), &file_contents)) { + ALOGE("Unable to read %s - %s", path.c_str(), strerror(errno)); + return false; + } else { + int64_t trips[8]; + + if (sscanf(file_contents.c_str(), + "%" SCNd64 " %" SCNd64 " %" SCNd64 " %" SCNd64 " %" SCNd64 " %" SCNd64 + " %" SCNd64 " %" SCNd64, + &trips[0], &trips[1], &trips[2], &trips[3], &trips[4], &trips[5], &trips[6], + &trips[7]) < 8) { + ALOGE("Unable to parse trip_counters %s from file %s", file_contents.c_str(), + path.c_str()); + return false; + } + + /* Trip#6 corresponds to DFS count */ + *val = trips[6]; + } + + return true; +} + +bool ThermalStatsReporter::captureThermalDfsStats( + const std::vector<std::string> &thermal_stats_paths, struct ThermalDfsCounts *pcur_data) { + bool report_stats = false; + std::string path; + + if (thermal_stats_paths.size() < kNumOfThermalDfsStats) { + ALOGE("Number of thermal stats paths (%zu) is less than expected (%d)", + thermal_stats_paths.size(), kNumOfThermalDfsStats); + return false; + } + + path = thermal_stats_paths[ThermalDfsStats::kBigDfsCountFieldNumber - kVendorAtomOffset]; + if (!readDfsCount(path, &(pcur_data->big_count))) { + pcur_data->big_count = prev_data.big_count; + } else { + report_stats |= (pcur_data->big_count > prev_data.big_count); + } + + path = thermal_stats_paths[ThermalDfsStats::kMidDfsCountFieldNumber - kVendorAtomOffset]; + if (!readDfsCount(path, &(pcur_data->mid_count))) { + pcur_data->mid_count = prev_data.mid_count; + } else { + report_stats |= (pcur_data->mid_count > prev_data.mid_count); + } + + path = thermal_stats_paths[ThermalDfsStats::kLittleDfsCountFieldNumber - kVendorAtomOffset]; + if (!readDfsCount(path, &(pcur_data->little_count))) { + pcur_data->little_count = prev_data.little_count; + } else { + report_stats |= (pcur_data->little_count > prev_data.little_count); + } + + path = thermal_stats_paths[ThermalDfsStats::kGpuDfsCountFieldNumber - kVendorAtomOffset]; + if (!readDfsCount(path, &(pcur_data->gpu_count))) { + pcur_data->gpu_count = prev_data.gpu_count; + } else { + report_stats |= (pcur_data->gpu_count > prev_data.gpu_count); + } + + path = thermal_stats_paths[ThermalDfsStats::kTpuDfsCountFieldNumber - kVendorAtomOffset]; + if (!readDfsCount(path, &(pcur_data->tpu_count))) { + pcur_data->tpu_count = prev_data.tpu_count; + } else { + report_stats |= (pcur_data->tpu_count > prev_data.tpu_count); + } + + path = thermal_stats_paths[ThermalDfsStats::kAurDfsCountFieldNumber - kVendorAtomOffset]; + if (!readDfsCount(path, &(pcur_data->aur_count))) { + pcur_data->aur_count = prev_data.aur_count; + } else { + report_stats |= (pcur_data->aur_count > prev_data.aur_count); + } + + return report_stats; +} + +void ThermalStatsReporter::logThermalDfsStats(const std::shared_ptr<IStats> &stats_client, + const std::vector<std::string> &thermal_stats_paths) { + struct ThermalDfsCounts cur_data = prev_data; + + if (!captureThermalDfsStats(thermal_stats_paths, &cur_data)) { + prev_data = cur_data; + ALOGI("No update found for thermal stats"); + return; + } + + VendorAtomValue tmp; + int64_t max_dfs_count = static_cast<int64_t>(INT32_MAX); + int dfs_count; + std::vector<VendorAtomValue> values(kNumOfThermalDfsStats); + + dfs_count = std::min<int64_t>(cur_data.big_count - prev_data.big_count, max_dfs_count); + tmp.set<VendorAtomValue::intValue>(dfs_count); + values[ThermalDfsStats::kBigDfsCountFieldNumber - kVendorAtomOffset] = tmp; + + dfs_count = std::min<int64_t>(cur_data.mid_count - prev_data.mid_count, max_dfs_count); + tmp.set<VendorAtomValue::intValue>(dfs_count); + values[ThermalDfsStats::kMidDfsCountFieldNumber - kVendorAtomOffset] = tmp; + + dfs_count = std::min<int64_t>(cur_data.little_count - prev_data.little_count, max_dfs_count); + tmp.set<VendorAtomValue::intValue>(dfs_count); + values[ThermalDfsStats::kLittleDfsCountFieldNumber - kVendorAtomOffset] = tmp; + + dfs_count = std::min<int64_t>(cur_data.gpu_count - prev_data.gpu_count, max_dfs_count); + tmp.set<VendorAtomValue::intValue>(dfs_count); + values[ThermalDfsStats::kGpuDfsCountFieldNumber - kVendorAtomOffset] = tmp; + + dfs_count = std::min<int64_t>(cur_data.tpu_count - prev_data.tpu_count, max_dfs_count); + tmp.set<VendorAtomValue::intValue>(dfs_count); + values[ThermalDfsStats::kTpuDfsCountFieldNumber - kVendorAtomOffset] = tmp; + + dfs_count = std::min<int64_t>(cur_data.aur_count - prev_data.aur_count, max_dfs_count); + tmp.set<VendorAtomValue::intValue>(dfs_count); + values[ThermalDfsStats::kAurDfsCountFieldNumber - kVendorAtomOffset] = tmp; + + prev_data = cur_data; + + ALOGD("Report updated thermal metrics to stats service"); + // Send vendor atom to IStats HAL + VendorAtom event = {.reverseDomainName = "", + .atomId = PixelAtoms::Atom::kThermalDfsStats, + .values = std::move(values)}; + const ndk::ScopedAStatus ret = stats_client->reportVendorAtom(event); + if (!ret.isOk()) + ALOGE("Unable to report thermal DFS stats to Stats service"); +} + +void ThermalStatsReporter::logThermalStats(const std::shared_ptr<IStats> &stats_client, + const std::vector<std::string> &thermal_stats_paths) { + logThermalDfsStats(stats_client, thermal_stats_paths); +} + +} // namespace pixel +} // namespace google +} // namespace hardware +} // namespace android diff --git a/pixelstats/UeventListener.cpp b/pixelstats/UeventListener.cpp index b5f31cb2..07c8c954 100644 --- a/pixelstats/UeventListener.cpp +++ b/pixelstats/UeventListener.cpp @@ -48,7 +48,6 @@ #include <log/log.h> #include <pixelstats/StatsHelper.h> #include <pixelstats/UeventListener.h> -#include <pixelstats/WlcReporter.h> #include <sys/stat.h> #include <sys/types.h> #include <unistd.h> @@ -67,7 +66,6 @@ using aidl::android::frameworks::stats::VendorAtomValue; using android::sp; using android::base::ReadFileToString; using android::base::WriteStringToFile; -using android::hardware::google::pixel::WlcReporter; using android::hardware::google::pixel::PixelAtoms::PdVidPid; using android::hardware::google::pixel::PixelAtoms::VendorHardwareFailed; using android::hardware::google::pixel::PixelAtoms::VendorUsbPortOverheat; @@ -185,17 +183,6 @@ void UeventListener::ReportChargeMetricsEvent(const std::shared_ptr<IStats> &sta charge_stats_reporter_.checkAndReport(stats_client, kChargeMetricsPath); } -/* ReportWlc - * Report wireless relate metrics when wireless charging start - */ -void UeventListener::ReportWlc(const std::shared_ptr<IStats> &stats_client, const bool pow_wireless, - const bool online, const char *ptmc) { - if (!pow_wireless) { - return; - } - - wlc_reporter_.checkAndReport(stats_client, online, ptmc); -} /** * Report raw battery capacity, system battery capacity and associated * battery capacity curves. This data is collected to verify the filter @@ -291,9 +278,6 @@ bool UeventListener::ProcessUevent() { const char *mic_break_status, *mic_degrade_status; const char *devpath; bool collect_partner_id = false; - bool pow_online; - bool pow_wireless; - const char *pow_ptmc; int n; if (uevent_fd_ < 0) { @@ -322,8 +306,7 @@ bool UeventListener::ProcessUevent() { msg[n + 1] = '\0'; driver = product = subsystem = NULL; - mic_break_status = mic_degrade_status = devpath = pow_ptmc = NULL; - pow_online = pow_wireless = false; + mic_break_status = mic_degrade_status = devpath = NULL; /** * msg is a sequence of null-terminated strings. @@ -350,15 +333,6 @@ bool UeventListener::ProcessUevent() { subsystem = cp; } else if (!strncmp(cp, kTypeCPartnerUevent.c_str(), kTypeCPartnerUevent.size())) { collect_partner_id = true; - } else if (!strncmp(cp, "POWER_SUPPLY_NAME=wireless", - strlen("POWER_SUPPLY_NAME=wireless"))) { - pow_wireless = true; - } else if (!strncmp(cp, "POWER_SUPPLY_ONLINE=1", strlen("POWER_SUPPLY_ONLINE=1"))) { - pow_online = true; - } else if (!kWirelessChargerPtmcUevent.empty() && - !strncmp(cp, kWirelessChargerPtmcUevent.c_str(), - strlen(kWirelessChargerPtmcUevent.c_str()))) { - pow_ptmc = cp + strlen(kWirelessChargerPtmcUevent.c_str()); } /* advance to after the next \0 */ while (*cp++) { @@ -374,7 +348,6 @@ bool UeventListener::ProcessUevent() { ReportMicStatusUevents(stats_client, devpath, mic_degrade_status); ReportUsbPortOverheatEvent(stats_client, driver); ReportChargeMetricsEvent(stats_client, driver); - ReportWlc(stats_client, pow_wireless, pow_online, pow_ptmc); ReportBatteryCapacityFGEvent(stats_client, subsystem); if (collect_partner_id) { ReportTypeCPartnerId(stats_client); @@ -399,8 +372,6 @@ UeventListener::UeventListener(const std::string audio_uevent, const std::string kTypeCPartnerUevent(typec_partner_uevent_default), kTypeCPartnerVidPath(typec_partner_vid_path), kTypeCPartnerPidPath(typec_partner_pid_path), - kWirelessChargerPtmcUevent(""), - kWirelessChargerPtmcPath(""), uevent_fd_(-1), log_fd_(-1) {} @@ -422,12 +393,6 @@ UeventListener::UeventListener(const struct UeventPaths &uevents_paths) kTypeCPartnerPidPath((uevents_paths.TypeCPartnerPidPath == nullptr) ? typec_partner_pid_path_default : uevents_paths.TypeCPartnerPidPath), - kWirelessChargerPtmcUevent((uevents_paths.WirelessChargerPtmcUevent == nullptr) - ? "" - : uevents_paths.WirelessChargerPtmcUevent), - kWirelessChargerPtmcPath((uevents_paths.WirelessChargerPtmcPath == nullptr) - ? "" - : uevents_paths.WirelessChargerPtmcPath), uevent_fd_(-1), log_fd_(-1) {} diff --git a/pixelstats/WlcReporter.cpp b/pixelstats/WlcReporter.cpp deleted file mode 100644 index 5a404d34..00000000 --- a/pixelstats/WlcReporter.cpp +++ /dev/null @@ -1,291 +0,0 @@ -/* - * Copyright (C) 2020 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-wlc" - -#include <android-base/file.h> -#include <android-base/strings.h> -#include <hardware/google/pixel/pixelstats/pixelatoms.pb.h> -#include <log/log.h> -#include <pixelstats/OrientationCollector.h> -#include <pixelstats/WlcReporter.h> -#include <sys/timerfd.h> -#include <time.h> -#include <utils/Timers.h> - -#include <thread> - -/* I set a higher rare limit ti orientation, beacuae user might try to adjust - * orientation when start charge - **/ -#define GOOGLE_PTMC_ID (0x72) -#define ID_UNKNOWN (0) -#define WLC_VENDOR_REPORT_RATE_LIMIT_MIN_SEC (60 * 60) -#define WLC_VENDOR_REPORT_RATE_LIMIT_MAX_COUNT_PER_DAY (10) -#define ORIENTATION_REPORT_RATE_LIMIT_MIN_SEC (0) -#define ORIENTATION_REPORT_RATE_LIMIT_MAX_COUNT_PER_DAY (10) -#define DAY_SECOND (86400) - -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; - -WlcReporter::WlcStatus::WlcStatus() - : is_charging(false), - check_charger_vendor_id(false), - check_charger_vendor_id_scheduled(false), - check_vendor_id_attempts(0) {} - -WlcReporter::ReportRecord::ReportRecord(char const *name_) - : name(name_), - last_reported_time_in_sec_today(0), - last_reported_time_in_sec(0), - count_today(0) {} - -WlcReporter::WlcReporter(const char *ptmc_path) : kWirelessChargerPtmcPath(ptmc_path) {} -void WlcReporter::checkAndReport(const std::shared_ptr<IStats> &stats_client, bool online, - const char *ptmc_uevent) { - bool wireless_charging = online; - bool started_wireless_charging = wireless_charging && !wlc_status_.is_charging; - wlc_status_.is_charging = wireless_charging; - ALOGV("reportVendorId is_charging: %s, started_wireless_charging: %s", - (wireless_charging) ? "true" : "false", (started_wireless_charging) ? "true" : "false"); - - if (started_wireless_charging) { - reportOrientation(stats_client); - wlc_status_.check_vendor_id_attempts = 0; - if (checkRateLimit(WLC_VENDOR_REPORT_RATE_LIMIT_MIN_SEC, - WLC_VENDOR_REPORT_RATE_LIMIT_MAX_COUNT_PER_DAY, &rec_wlc_vendor_)) { - wlc_status_.check_charger_vendor_id = true; - if (kWirelessChargerPtmcPath != nullptr && strlen(kWirelessChargerPtmcPath) != 0) { - scheduleReportVendorId(stats_client); - } else { - ALOGV("ptmc_path not set"); - } - } - } - if (!wireless_charging) { - wlc_status_.check_charger_vendor_id = false; - } - if (wireless_charging) { - checkVendorId(stats_client, ptmc_uevent); - } -} - -void WlcReporter::checkVendorId(const std::shared_ptr<IStats> &stats_client, - const char *ptmc_uevent) { - if (!ptmc_uevent || !wlc_status_.check_charger_vendor_id) { - return; - } - if (reportVendorMayRetry(stats_client, ptmc_uevent)) { - wlc_status_.check_charger_vendor_id = false; - } -} - -bool WlcReporter::reportVendorMayRetry(const std::shared_ptr<IStats> &stats_client, - const char *ptmc_uevent) { - int ptmcId = readPtmcId(ptmc_uevent); - if (ptmcId == ID_UNKNOWN) { - if (++(wlc_status_.check_vendor_id_attempts) < kMaxVendorIdAttempts) { - return false; - } /* else if ptmc not ready after retry assume ptmc not supported by charger */ - } - ALOGV("reportVendorId from Uevent"); - reportVendor(stats_client, ptmcId); - return true; -} -void WlcReporter::reportVendor(const std::shared_ptr<IStats> &stats_client, const int ptmcId) { - int vendorCharger = (ptmcId == GOOGLE_PTMC_ID) - ? PixelAtoms::WirelessChargingStats::VENDOR_GOOGLE - : PixelAtoms::WirelessChargingStats::VENDOR_UNKNOWN; - ALOGV("ptmcId: 0x%x; vendorCharger: %d", ptmcId, vendorCharger); - VendorAtomValue tmp; - tmp.set<VendorAtomValue::intValue>(vendorCharger); - - std::vector<VendorAtomValue> values(1); - values[PixelAtoms::WirelessChargingStats::kChargerVendorFieldNumber - kVendorAtomOffset] = tmp; - - // Send vendor atom to IStats HAL - VendorAtom event = {.reverseDomainName = "", - .atomId = PixelAtoms::Atom::kWirelessChargingStats, - .values = std::move(values)}; - const ndk::ScopedAStatus retStat = stats_client->reportVendorAtom(event); - if (!retStat.isOk()) { - ALOGE("Unable to report WLC_STATS to Stats service"); - } - return; -} - -int WlcReporter::readPtmcId(const char *ptmc_str) { - int id; - if (sscanf(ptmc_str, "%x", &id) != 1) { - return ID_UNKNOWN; - } - return id; -} - -void WlcReporter::scheduleReportVendorId(const std::shared_ptr<IStats> &stats_client) { - if (wlc_status_.check_charger_vendor_id_scheduled) { - return; - } - - wlc_status_.check_charger_vendor_id_scheduled = true; - std::thread taskThread(&WlcReporter::reportInBackground, this, stats_client, - kWirelessChargerPtmcPath); - taskThread.detach(); -} - -bool WlcReporter::ptmcWaitTimer(int timerfd) { - const int kDelaytimeBeforeReadPtmcId = 60; - struct itimerspec period; - period.it_interval.tv_sec = 0; - period.it_interval.tv_nsec = 0; - period.it_value.tv_sec = kDelaytimeBeforeReadPtmcId; - period.it_value.tv_nsec = 0; - - if (timerfd_settime(timerfd, 0, &period, nullptr)) { - ALOGE("Unable to set timer - %s", strerror(errno)); - return false; - } - int readval; - do { - char buf[8]; - errno = 0; - readval = read(timerfd, buf, sizeof(buf)); - } while (readval < 0 && errno == EINTR); - if (readval < 0) { - ALOGE("Timerfd error - %s", strerror(errno)); - return false; - } - return true; -} - -/* - * PTMC path use to sore wireless charger vendor id, - * and it take some time to get ready after wireless chagre start, - * to prevnt busy wait, I use timer and background thread to check PTMC ID - **/ -void WlcReporter::reportInBackground(const std::shared_ptr<IStats> &stats_client, - const char *ptmc_path) { - int timerfd = timerfd_create(CLOCK_BOOTTIME, 0); - if (timerfd < 0) { - ALOGE("Unable to create timerfd - %s", strerror(errno)); - return; - } - if (ptmcWaitTimer(timerfd)) { - if (!wlc_status_.is_charging) { - ALOGV("Not charging, skip report vender id"); - } else if (!wlc_status_.check_charger_vendor_id) { - ALOGV("id reported by uevnt, skip report vender id"); - } else { - std::string file_contents; - if (!ReadFileToString(ptmc_path, &file_contents)) { - ALOGE("ReadFileToString %s fail", ptmc_path); - } else { - int ptmcId = readPtmcId(file_contents.c_str()); - ALOGV("reportVendorId from file"); - reportVendor(stats_client, ptmcId); - } - } - } - wlc_status_.check_charger_vendor_id_scheduled = false; - close(timerfd); -} - -/* Reference to frameworks/native/libs/ui/include/ui/DisplayInfo.h - * translate orientation value from sensor to enum define in - * pixelatoms.proto - */ -int WlcReporter::translateDeviceOrientationToAtomValue(int orientation) { - switch (orientation) { - case 0: - return PixelAtoms::DeviceOrientation::ORIENTATION_0; - case 1: - return PixelAtoms::DeviceOrientation::ORIENTATION_90; - case 2: - return PixelAtoms::DeviceOrientation::ORIENTATION_180; - case 3: - return PixelAtoms::DeviceOrientation::ORIENTATION_270; - default: - return PixelAtoms::DeviceOrientation::ORIENTATION_UNKNOWN; - } -} - -void WlcReporter::reportOrientation(const std::shared_ptr<IStats> &stats_client) { - ALOGV("reportOrientation"); - if (!checkRateLimit(ORIENTATION_REPORT_RATE_LIMIT_MIN_SEC, - ORIENTATION_REPORT_RATE_LIMIT_MAX_COUNT_PER_DAY, &rec_orientation_)) { - return; - } - sp<OrientationCollector> orientationCollector = - OrientationCollector::createOrientationCollector(); - if (orientationCollector != nullptr) { - int orientationFromSensor = -1; - orientationCollector->pollOrientation(&orientationFromSensor); - VendorAtomValue tmp; - tmp.set<VendorAtomValue::intValue>( - translateDeviceOrientationToAtomValue(orientationFromSensor)); - - std::vector<VendorAtomValue> values(1); - values[PixelAtoms::DeviceOrientation::kOrientationFieldNumber - kVendorAtomOffset] = tmp; - - VendorAtom event = {.reverseDomainName = "", - .atomId = PixelAtoms::Atom::kDeviceOrientation, - .values = std::move(values)}; - const ndk::ScopedAStatus retStat = stats_client->reportVendorAtom(event); - if (!retStat.isOk()) { - ALOGE("Unable to report Orientation to Stats service"); - } - orientationCollector->disableOrientationSensor(); - } -} - -bool WlcReporter::checkRateLimit(int64_t minSecond, int maxCount, ReportRecord *rec) { - if (rec == nullptr) { - ALOGE("ReportRecord should not be NULL"); - return false; - } - int64_t now = nanoseconds_to_seconds(systemTime(SYSTEM_TIME_BOOTTIME)); - if (rec->last_reported_time_in_sec > 0 && now - rec->last_reported_time_in_sec < minSecond) { - ALOGV("%s: Rate limit, min period: %ld", rec->name, minSecond); - return false; - } - if (rec->last_reported_time_in_sec_today == 0) { - rec->last_reported_time_in_sec_today = now; - ALOGV("%s: reset day time (init)", rec->name); - } else if (now - rec->last_reported_time_in_sec_today > DAY_SECOND) { - rec->last_reported_time_in_sec_today = now; - rec->count_today = 0; - ALOGV("%s: reset day time", rec->name); - } else if (rec->count_today >= maxCount) { - ALOGV("%s: Rate limit, max count: %d", rec->name, maxCount); - return false; - } - (rec->count_today)++; - ALOGV("%s: checkRateLimit count: %d", rec->name, rec->count_today); - rec->last_reported_time_in_sec = now; - return true; -} -} // namespace pixel -} // namespace google -} // namespace hardware -} // namespace android diff --git a/pixelstats/include/pixelstats/BrownoutDetectedReporter.h b/pixelstats/include/pixelstats/BrownoutDetectedReporter.h new file mode 100644 index 00000000..5f460d9f --- /dev/null +++ b/pixelstats/include/pixelstats/BrownoutDetectedReporter.h @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2022 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. + */ + +#ifndef HARDWARE_GOOGLE_PIXEL_PIXELSTATS_BROWNOUTDETECTEDREPORTER_H +#define HARDWARE_GOOGLE_PIXEL_PIXELSTATS_BROWNOUTDETECTEDREPORTER_H + +#include <aidl/android/frameworks/stats/IStats.h> +#include <hardware/google/pixel/pixelstats/pixelatoms.pb.h> + +#include <map> +#include <regex> +#include <string> + +namespace android { +namespace hardware { +namespace google { +namespace pixel { + +using aidl::android::frameworks::stats::IStats; +using aidl::android::frameworks::stats::VendorAtomValue; + +#define ODPM_MAX_IDX 24 +#define DVFS_MAX_IDX 6 +enum Update { kUpdateMax, kUpdateMin }; + +/** + * A class to upload Pixel Brownout metrics + */ +class BrownoutDetectedReporter { + public: + void logBrownout(const std::shared_ptr<IStats> &stats_client, const std::string &logFilePath, + const std::string &brownoutReasonProp); + + private: + struct BrownoutDetectedInfo { + int triggered_irq_; + long triggered_timestamp_; + int battery_temp_; + int battery_cycle_; + int battery_soc_; + int voltage_now_; + int odpm_value_[ODPM_MAX_IDX]; + int dvfs_value_[DVFS_MAX_IDX]; + int brownout_reason_; + }; + + void setAtomFieldValue(std::vector<VendorAtomValue> *values, int offset, int content); + long parseTimestamp(std::string timestamp); + bool updateIfFound(std::string line, std::regex pattern, int *current_value, Update flag); + void uploadData(const std::shared_ptr<IStats> &stats_client, + const struct BrownoutDetectedInfo max_value); + // Proto messages are 1-indexed and VendorAtom field numbers start at 2, so + // store everything in the values array at the index of the field number + // -2. + const int kVendorAtomOffset = 2; +}; + +} // namespace pixel +} // namespace google +} // namespace hardware +} // namespace android + +#endif // HARDWARE_GOOGLE_PIXEL_PIXELSTATS_BROWNOUTDETECTEDREPORTER_H diff --git a/pixelstats/include/pixelstats/ChargeStatsReporter.h b/pixelstats/include/pixelstats/ChargeStatsReporter.h index 098154a6..62c3abc9 100644 --- a/pixelstats/include/pixelstats/ChargeStatsReporter.h +++ b/pixelstats/include/pixelstats/ChargeStatsReporter.h @@ -37,16 +37,20 @@ class ChargeStatsReporter { void checkAndReport(const std::shared_ptr<IStats> &stats_client, const std::string &path); private: - bool checkThermalContentsAndAck(std::string *file_contents); + bool checkContentsAndAck(std::string *file_contents, const std::string &path); void ReportVoltageTierStats(const std::shared_ptr<IStats> &stats_client, const char *line, const bool has_wireless, const std::string &wfile_contents); void ReportChargeStats(const std::shared_ptr<IStats> &stats_client, const std::string line, const std::string wline_at, const std::string wline_ac, const std::string pca_line); + bool shouldReportEvent(void); + int64_t getTimeSecs(void); WirelessChargeStats wireless_charge_stats_; PcaChargeStats pca_charge_stats_; + int log_event_time_secs_ = 0; + // Proto messages are 1-indexed and VendorAtom field numbers start at 2, so // store everything in the values array at the index of the field number // -2. @@ -54,6 +58,8 @@ class ChargeStatsReporter { const std::string kThermalChargeMetricsPath = "/sys/devices/platform/google,charger/thermal_stats"; + + const std::string kGChargerMetricsPath = "/sys/devices/platform/google,charger/charge_stats"; }; } // namespace pixel diff --git a/pixelstats/include/pixelstats/MmMetricsReporter.h b/pixelstats/include/pixelstats/MmMetricsReporter.h index 89f12f59..cfcfac3a 100644 --- a/pixelstats/include/pixelstats/MmMetricsReporter.h +++ b/pixelstats/include/pixelstats/MmMetricsReporter.h @@ -37,6 +37,7 @@ using aidl::android::frameworks::stats::VendorAtomValue; class MmMetricsReporter { public: MmMetricsReporter(); + void aggregatePixelMmMetricsPer5Min(); void logPixelMmMetricsPerHour(const std::shared_ptr<IStats> &stats_client); void logPixelMmMetricsPerDay(const std::shared_ptr<IStats> &stats_client); void logCmaStatus(const std::shared_ptr<IStats> &stats_client); @@ -62,6 +63,43 @@ class MmMetricsReporter { static const std::vector<MmMetricsInfo> kCmaStatusInfo; static const std::vector<MmMetricsInfo> kCmaStatusExtInfo; + // raw PSI + static constexpr const char *kPsiBasePath = "/proc/pressure"; + static constexpr const char *kPsiTypes[3] = {"cpu", "io", "memory"}; + static constexpr const char *kPsiCategories[2] = {"full", "some"}; + static constexpr const char *kPsiMetricNames[4] = {"avg10", "avg60", "avg300", "total"}; + static constexpr int kPsiNumFiles = sizeof(kPsiTypes) / sizeof(kPsiTypes[0]); + static constexpr int kPsiNumCategories = sizeof(kPsiCategories) / sizeof(kPsiCategories[0]); + // number of statistics metric names (one total and several timed averages, per category) + static constexpr int kPsiNumNames = sizeof(kPsiMetricNames) / sizeof(kPsiMetricNames[0]); + + // Though cpu has no 'full' category, here we assume it has + // So, all file will contain 2 lines x 4 metrics per line = 8 metrics total. + static constexpr int kPsiMetricsPerFile = kPsiNumCategories * kPsiNumNames; + + // we have 1 'total' and all others 'averages' per category + // "total" metrics are already accumulative and thus no aggregation is needed. + // raw values are used. + static constexpr int kPsiNumTotals = 1; + static constexpr int kPsiNumAvgs = kPsiNumNames - kPsiNumTotals; + + // -1 since "cpu" type has no "full" category + static constexpr int kPsiNumAllCategories = kPsiNumFiles * kPsiNumCategories - 1; + + // number of raw metrics: total and avgs, and the combined all: added together. + static constexpr int kPsiNumAllTotals = kPsiNumAllCategories * kPsiNumTotals; + static constexpr int kPsiNumAllAvgs = kPsiNumAllCategories * kPsiNumAvgs; + static constexpr int kPsiNumAllMetrics = kPsiNumAllTotals + kPsiNumAllAvgs; + + // aggregated into (1) min, (2) max, (3) average (internally the sum is kept than the average) + static constexpr int kPsiNumOfAggregatedType = 3; + + // # of upload metrics will have a aggregation factor on all 'average' type raw metrics. + static constexpr int kPsiNumAllUploadAvgMetrics = kPsiNumAllAvgs * kPsiNumOfAggregatedType; + static constexpr int kPsiNumAllUploadTotalMetrics = kPsiNumAllTotals; + static constexpr int kPsiNumAllUploadMetrics = + kPsiNumAllUploadTotalMetrics + kPsiNumAllUploadAvgMetrics; + bool checkKernelMMMetricSupport(); bool MmMetricsSupported() { @@ -80,6 +118,21 @@ class MmMetricsReporter { bool ReadFileToUint(const char *const path, uint64_t *val); bool reportVendorAtom(const std::shared_ptr<IStats> &stats_client, int atom_id, const std::vector<VendorAtomValue> &values, const std::string &atom_name); + void readCompactionDurationStat(std::vector<long> *store); + void fillCompactionDurationStatAtom(const std::vector<long> &store, + std::vector<VendorAtomValue> *values); + void readDirectReclaimStat(std::vector<long> *store); + void fillDirectReclaimStatAtom(const std::vector<long> &store, + std::vector<VendorAtomValue> *values); + void readPressureStall(const char *basePath, std::vector<long> *store); + bool parsePressureStallFileContent(bool is_cpu, std::string lines, std::vector<long> *store, + int file_save_idx); + bool parsePressureStallWords(std::vector<std::string> words, std::vector<long> *store, + int line_save_idx); + bool savePressureMetrics(std::string name, std::string value, std::vector<long> *store, + int base_save_idx); + void fillPressureStallAtom(std::vector<VendorAtomValue> *values); + void aggregatePressureStall(); std::map<std::string, uint64_t> readVmStat(const char *path); uint64_t getIonTotalPools(); uint64_t getGpuMemory(); @@ -103,12 +156,22 @@ class MmMetricsReporter { const char *const kIonTotalPoolsPath; const char *const kIonTotalPoolsPathForLegacy; const char *const kGpuTotalPages; + const char *const kCompactDuration; + const char *const kDirectReclaimBasePath; const char *const kPixelStatMm; // Proto messages are 1-indexed and VendorAtom field numbers start at 2, so // store everything in the values array at the index of the field number // -2. - const int kVendorAtomOffset = 2; - + static constexpr int kVendorAtomOffset = 2; + static constexpr int kNumCompactionDurationPrevMetrics = 6; + static constexpr int kNumDirectReclaimPrevMetrics = 20; + + std::vector<long> prev_compaction_duration_; + std::vector<long> prev_direct_reclaim_; + long prev_psi_total_[kPsiNumAllTotals]; + long psi_total_[kPsiNumAllTotals]; + long psi_aggregated_[kPsiNumAllUploadAvgMetrics]; // min, max and avg of original avgXXX + int psi_data_set_count_ = 0; std::map<std::string, uint64_t> prev_hour_vmstat_; std::map<std::string, uint64_t> prev_day_vmstat_; std::map<std::string, uint64_t> prev_day_pixel_vmstat_; diff --git a/pixelstats/include/pixelstats/OrientationCollector.h b/pixelstats/include/pixelstats/OrientationCollector.h deleted file mode 100644 index e3ca6416..00000000 --- a/pixelstats/include/pixelstats/OrientationCollector.h +++ /dev/null @@ -1,52 +0,0 @@ -/* - * Copyright (C) 2020 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. - */ - -#include <android/hidl/base/1.0/IBase.h> -#include <android/sensor.h> - -#ifndef HARDWARE_GOOGLE_PIXEL_ORIENTATION_COLLECTOR_H -#define HARDWARE_GOOGLE_PIXEL_ORIENTATION_COLLECTOR_H - -namespace android { -namespace hardware { -namespace google { -namespace pixel { - -/** - * A class to help use Senser - */ -class OrientationCollector : public RefBase { - public: - static sp<OrientationCollector> createOrientationCollector(); - - int32_t pollOrientation(int *orientation); - int32_t init(); - void disableOrientationSensor(); - - private: - ASensorEventQueue *mQueue; - ASensorManager *mSensorManager = nullptr; - ASensorRef mOrientationSensor; - - int getEvents(ASensorEvent *event_list, size_t event_list_size, int *event_count); -}; - -} // namespace pixel -} // namespace google -} // namespace hardware -} // namespace android - -#endif // HARDWARE_GOOGLE_PIXEL_ORIENTATION_COLLECTOR_H diff --git a/pixelstats/include/pixelstats/PcaChargeStats.h b/pixelstats/include/pixelstats/PcaChargeStats.h index 90a6c3e0..90c65357 100644 --- a/pixelstats/include/pixelstats/PcaChargeStats.h +++ b/pixelstats/include/pixelstats/PcaChargeStats.h @@ -25,12 +25,18 @@ namespace pixel { class PcaChargeStats { public: PcaChargeStats(const std::string pca_charge_metrics_path = - "/sys/class/power_supply/pca9468-mains/device/chg_stats"); + "/sys/class/power_supply/pca9468-mains/device/chg_stats", + const std::string pca94xx_charge_metrics_path = + "/sys/class/power_supply/pca94xx-mains/device/chg_stats", + const std::string dc_charge_metrics_path = + "/sys/class/power_supply/dc-mains/device/chg_stats"); bool CheckPcaContentsAndAck(std::string *file_contents); private: const std::string kPcaChargeMetricsPath; + const std::string kPca94xxChargeMetricsPath; + const std::string kDcChargeMetricsPath; }; } // namespace pixel diff --git a/pixelstats/include/pixelstats/SysfsCollector.h b/pixelstats/include/pixelstats/SysfsCollector.h index 2baa53c5..1054cc54 100644 --- a/pixelstats/include/pixelstats/SysfsCollector.h +++ b/pixelstats/include/pixelstats/SysfsCollector.h @@ -22,8 +22,11 @@ #include "BatteryEEPROMReporter.h" #include "BatteryHealthReporter.h" +#include "BrownoutDetectedReporter.h" #include "MitigationStatsReporter.h" #include "MmMetricsReporter.h" +#include "TempResidencyReporter.h" +#include "ThermalStatsReporter.h" namespace android { namespace hardware { @@ -56,10 +59,21 @@ class SysfsCollector { const char *const ZramBdStatPath; const char *const EEPROMPath; const char *const MitigationPath; + const char *const BrownoutLogPath; + const char *const BrownoutReasonProp; const char *const SpeakerTemperaturePath; const char *const SpeakerExcursionPath; const char *const SpeakerHeartBeatPath; const std::vector<std::string> UFSErrStatsPath; + const int BlockStatsLength; + const char *const AmsRatePath; + const std::vector<std::string> ThermalStatsPaths; + const char *const CCARatePath; + const std::vector<std::pair<std::string, std::string>> TempResidencyAndResetPaths; + const char *const LongIRQMetricsPath; + const char *const ResumeLatencyMetricsPath; + const char *const ModemPcieLinkStatsPath; + const char *const WifiPcieLinkStatsPath; }; SysfsCollector(const struct SysfsPaths &paths); @@ -68,11 +82,15 @@ class SysfsCollector { private: bool ReadFileToInt(const std::string &path, int *val); bool ReadFileToInt(const char *path, int *val); + void aggregatePer5Min(); + void logOnce(); + void logBrownout(); void logPerDay(); void logPerHour(); void logBatteryChargeCycles(const std::shared_ptr<IStats> &stats_client); void logBatteryHealth(const std::shared_ptr<IStats> &stats_client); + void logBlockStatsReported(const std::shared_ptr<IStats> &stats_client); void logCodecFailed(const std::shared_ptr<IStats> &stats_client); void logCodec1Failed(const std::shared_ptr<IStats> &stats_client); void logSlowIO(const std::shared_ptr<IStats> &stats_client); @@ -82,18 +100,27 @@ class SysfsCollector { void logUFSLifetime(const std::shared_ptr<IStats> &stats_client); void logUFSErrorStats(const std::shared_ptr<IStats> &stats_client); void logF2fsStats(const std::shared_ptr<IStats> &stats_client); + void logF2fsAtomicWriteInfo(const std::shared_ptr<IStats> &stats_client); void logF2fsCompressionInfo(const std::shared_ptr<IStats> &stats_client); void logF2fsGcSegmentInfo(const std::shared_ptr<IStats> &stats_client); void logZramStats(const std::shared_ptr<IStats> &stats_client); void logBootStats(const std::shared_ptr<IStats> &stats_client); void logBatteryEEPROM(const std::shared_ptr<IStats> &stats_client); void logSpeakerHealthStats(const std::shared_ptr<IStats> &stats_client); + void logF2fsSmartIdleMaintEnabled(const std::shared_ptr<IStats> &stats_client); + void logThermalStats(const std::shared_ptr<IStats> &stats_client); void reportSlowIoFromFile(const std::shared_ptr<IStats> &stats_client, const char *path, const VendorSlowIo::IoOperation &operation_s); + void logTempResidencyStats(const std::shared_ptr<IStats> &stats_client); void reportZramMmStat(const std::shared_ptr<IStats> &stats_client); void reportZramBdStat(const std::shared_ptr<IStats> &stats_client); int getReclaimedSegments(const std::string &mode); + void logVendorAudioHardwareStats(const std::shared_ptr<IStats> &stats_client); + void logVendorLongIRQStatsReported(const std::shared_ptr<IStats> &stats_client); + void logVendorResumeLatencyStats(const std::shared_ptr<IStats> &stats_client); + void logPartitionUsedSpace(const std::shared_ptr<IStats> &stats_client); + void logPcieLinkStats(const std::shared_ptr<IStats> &stats_client); const char *const kSlowioReadCntPath; const char *const kSlowioWriteCntPath; @@ -113,17 +140,30 @@ class SysfsCollector { const char *const kZramMmStatPath; const char *const kZramBdStatPath; const char *const kEEPROMPath; + const char *const kBrownoutLogPath; + const char *const kBrownoutReasonProp; const char *const kPowerMitigationStatsPath; const char *const kSpeakerTemperaturePath; const char *const kSpeakerExcursionPath; const char *const kSpeakerHeartbeatPath; const std::vector<std::string> kUFSErrStatsPath; + const int kBlockStatsLength; + const char *const kAmsRatePath; + const std::vector<std::string> kThermalStatsPaths; + const char *const kCCARatePath; + const std::vector<std::pair<std::string, std::string>> kTempResidencyAndResetPaths; + const char *const kLongIRQMetricsPath; + const char *const kResumeLatencyMetricsPath; + const char *const kModemPcieLinkStatsPath; + const char *const kWifiPcieLinkStatsPath; BatteryEEPROMReporter battery_EEPROM_reporter_; MmMetricsReporter mm_metrics_reporter_; MitigationStatsReporter mitigation_stats_reporter_; + BrownoutDetectedReporter brownout_detected_reporter_; + ThermalStatsReporter thermal_stats_reporter_; BatteryHealthReporter battery_health_reporter_; - + TempResidencyReporter temp_residency_reporter_; // Proto messages are 1-indexed and VendorAtom field numbers start at 2, so // store everything in the values array at the index of the field number // -2. @@ -131,6 +171,17 @@ class SysfsCollector { bool log_once_reported = false; int64_t prev_huge_pages_since_boot_ = -1; + + struct perf_metrics_data { + int64_t softirq_count; + int64_t irq_count; + uint64_t resume_latency_sum_ms; + int64_t resume_count; + std::vector<int64_t> resume_latency_buckets; + int bucket_cnt; + }; + struct perf_metrics_data prev_data; + const int kMaxResumeLatencyBuckets = 36; }; } // namespace pixel diff --git a/pixelstats/include/pixelstats/TempResidencyReporter.h b/pixelstats/include/pixelstats/TempResidencyReporter.h new file mode 100644 index 00000000..b19d7627 --- /dev/null +++ b/pixelstats/include/pixelstats/TempResidencyReporter.h @@ -0,0 +1,55 @@ +/* + * 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. + */ + +#include <aidl/android/frameworks/stats/IStats.h> +#include <android-base/chrono_utils.h> +#include <hardware/google/pixel/pixelstats/pixelatoms.pb.h> + +#include <string> + +namespace android { +namespace hardware { +namespace google { +namespace pixel { + +using aidl::android::frameworks::stats::IStats; +using aidl::android::frameworks::stats::VendorAtomValue; + +struct TempResidencyStats { + std::vector<int64_t> temp_residency_buckets; + float max_temp, min_temp; + int64_t max_temp_timestamp, min_temp_timestamp; +}; + +/** + * A class to upload Pixel TempResidency Stats metrics + */ +class TempResidencyReporter { + public: + void logTempResidencyStats(const std::shared_ptr<IStats> &stats_client, + std::string_view temperature_residency_path, + std::string_view temperature_residency_reset_path); + + private: + ::android::base::boot_clock::time_point prevTime = + ::android::base::boot_clock::time_point::min(); + const int kMaxBucketLen = 20; +}; + +} // namespace pixel +} // namespace google +} // namespace hardware +} // namespace android diff --git a/pixelstats/include/pixelstats/ThermalStatsReporter.h b/pixelstats/include/pixelstats/ThermalStatsReporter.h new file mode 100644 index 00000000..57f246eb --- /dev/null +++ b/pixelstats/include/pixelstats/ThermalStatsReporter.h @@ -0,0 +1,71 @@ +/* + * 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. + */ + +#ifndef HARDWARE_GOOGLE_PIXEL_PIXELSTATS_THERMALSTATSREPORTER_H +#define HARDWARE_GOOGLE_PIXEL_PIXELSTATS_THERMALSTATSREPORTER_H + +#include <aidl/android/frameworks/stats/IStats.h> +#include <hardware/google/pixel/pixelstats/pixelatoms.pb.h> + +#include <string> + +namespace android { +namespace hardware { +namespace google { +namespace pixel { + +using aidl::android::frameworks::stats::IStats; +using aidl::android::frameworks::stats::VendorAtomValue; + +/** + * A class to upload Pixel Thermal Stats metrics + */ +class ThermalStatsReporter { + public: + ThermalStatsReporter(); + void logThermalStats(const std::shared_ptr<IStats> &stats_client, + const std::vector<std::string> &thermal_stats_paths); + + private: + struct ThermalDfsCounts { + int64_t big_count; + int64_t mid_count; + int64_t little_count; + int64_t gpu_count; + int64_t tpu_count; + int64_t aur_count; + }; + + // Proto messages are 1-indexed and VendorAtom field numbers start at 2, so + // store everything in the values array at the index of the field number + // -2. + const int kVendorAtomOffset = 2; + const int kNumOfThermalDfsStats = 6; + struct ThermalDfsCounts prev_data; + + void logThermalDfsStats(const std::shared_ptr<IStats> &stats_client, + const std::vector<std::string> &thermal_stats_paths); + bool captureThermalDfsStats(const std::vector<std::string> &thermal_stats_paths, + struct ThermalDfsCounts *cur_data); + bool readDfsCount(const std::string &path, int64_t *val); +}; + +} // namespace pixel +} // namespace google +} // namespace hardware +} // namespace android + +#endif // HARDWARE_GOOGLE_PIXEL_PIXELSTATS_THERMALSTATSREPORTER_H diff --git a/pixelstats/include/pixelstats/UeventListener.h b/pixelstats/include/pixelstats/UeventListener.h index 876098d2..5316afaa 100644 --- a/pixelstats/include/pixelstats/UeventListener.h +++ b/pixelstats/include/pixelstats/UeventListener.h @@ -21,8 +21,6 @@ #include <android-base/chrono_utils.h> #include <pixelstats/BatteryCapacityReporter.h> #include <pixelstats/ChargeStatsReporter.h> -#include <pixelstats/PcaChargeStats.h> -#include <pixelstats/WlcReporter.h> namespace android { namespace hardware { @@ -39,10 +37,6 @@ using aidl::android::frameworks::stats::IStats; */ class UeventListener { public: - /* Both WirelessChargerPtmcUevent and WirelessChargerPtmcPath is use to get - * wireless charger ptmx id, for most case we don't need asisign both of - * them. - **/ struct UeventPaths { const char *const AudioUevent; const char *const SsocDetailsPath; @@ -51,8 +45,8 @@ class UeventListener { const char *const TypeCPartnerUevent; const char *const TypeCPartnerVidPath; const char *const TypeCPartnerPidPath; - const char *const WirelessChargerPtmcUevent; - const char *const WirelessChargerPtmcPath; + const char *const WirelessChargerPtmcUevent; // Deprecated. + const char *const WirelessChargerPtmcPath; // Deprecated. }; constexpr static const char *const ssoc_details_path = "/sys/class/power_supply/battery/ssoc_details"; @@ -91,8 +85,6 @@ class UeventListener { void ReportVoltageTierStats(const std::shared_ptr<IStats> &stats_client, const char *line, const bool has_wireless, const std::string wfile_contents); void ReportChargeMetricsEvent(const std::shared_ptr<IStats> &stats_client, const char *driver); - void ReportWlc(const std::shared_ptr<IStats> &stats_client, const bool pow_wireless, - const bool online, const char *ptmc); void ReportBatteryCapacityFGEvent(const std::shared_ptr<IStats> &stats_client, const char *subsystem); void ReportTypeCPartnerId(const std::shared_ptr<IStats> &stats_client); @@ -104,8 +96,6 @@ class UeventListener { const std::string kTypeCPartnerUevent; const std::string kTypeCPartnerVidPath; const std::string kTypeCPartnerPidPath; - const std::string kWirelessChargerPtmcUevent; - const std::string kWirelessChargerPtmcPath; BatteryCapacityReporter battery_capacity_reporter_; ChargeStatsReporter charge_stats_reporter_; @@ -117,8 +107,6 @@ class UeventListener { int uevent_fd_; int log_fd_; - - WlcReporter wlc_reporter_ = WlcReporter(kWirelessChargerPtmcPath.c_str()); }; } // namespace pixel diff --git a/pixelstats/include/pixelstats/WlcReporter.h b/pixelstats/include/pixelstats/WlcReporter.h deleted file mode 100644 index e9793692..00000000 --- a/pixelstats/include/pixelstats/WlcReporter.h +++ /dev/null @@ -1,98 +0,0 @@ -/* - * Copyright (C) 2020 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. - */ - -#ifndef HARDWARE_GOOGLE_PIXEL_PIXELSTATS_WLCREPORTER_H -#define HARDWARE_GOOGLE_PIXEL_PIXELSTATS_WLCREPORTER_H - -#include <aidl/android/frameworks/stats/IStats.h> -#include <utils/RefBase.h> - -#include <cstdint> - -namespace android { -namespace hardware { -namespace google { -namespace pixel { - -using aidl::android::frameworks::stats::IStats; - -/** - * A class to upload wireless metrics - */ -class WlcReporter : public RefBase { - public: - void checkAndReport(const std::shared_ptr<IStats> &stats_client, const bool online, - const char *ptmc_uevent); - - WlcReporter(const char *ptmc_path); - - private: - struct WlcStatus { - bool is_charging; - bool check_charger_vendor_id; - bool check_charger_vendor_id_scheduled; - int check_vendor_id_attempts; - WlcStatus(); - }; - WlcStatus wlc_status_; - struct ReportRecord { - char const *name; - int64_t last_reported_time_in_sec_today; - int64_t last_reported_time_in_sec; - int count_today; - ReportRecord(char const *name_); - }; - ReportRecord rec_wlc_vendor_{"wlc_vendor"}; - ReportRecord rec_orientation_{"orientation"}; - - void checkVendorId(const std::shared_ptr<IStats> &stats_client, const char *ptmc_uevent); - void scheduleReportVendorId(const std::shared_ptr<IStats> &stats_client); - void reportOrientation(const std::shared_ptr<IStats> &stats_client); - void reportVendor(const std::shared_ptr<IStats> &stats_client, const int ptmcId); - bool reportVendorMayRetry(const std::shared_ptr<IStats> &stats_client, const char *ptmc_uevent); - // Translate device orientation value from sensor Hal to atom enum value - int translateDeviceOrientationToAtomValue(int orientation); - void reportInBackground(const std::shared_ptr<IStats> &stats_client, const char *ptmc_path); - /* - * Wait timer for make delay before read ptmc path, return false on error - * timerfd: fd create by timerfd_create, need create/close by caller - **/ - bool ptmcWaitTimer(int timerfd); - /* For some case (ex if wireless charger was connect to a low power PTMC AC - * adapter), the wireless charger keep restaring (it might casuse will - * check and update data in a not reasonable rare). - * return: true, it has not hit upload rare limit - * false, it has hit rate litmit, we should drop current - * upload atom - **/ - bool checkRateLimit(int64_t minSecond, int maxCount, ReportRecord *rec); - - // Proto messages are 1-indexed and VendorAtom field numbers start at 2, so - // store everything in the values array at the index of the field number - // -2. - const int kVendorAtomOffset = 2; - const int kMaxVendorIdAttempts = 5; - const char *kWirelessChargerPtmcPath; - - int readPtmcId(const char *ptmc_str); -}; - -} // namespace pixel -} // namespace google -} // namespace hardware -} // namespace android - -#endif // HARDWARE_GOOGLE_PIXEL_PIXELSTATS_WLCREPORTER_H diff --git a/pixelstats/pixelatoms.proto b/pixelstats/pixelatoms.proto index 9ffb7083..80657e66 100644 --- a/pixelstats/pixelatoms.proto +++ b/pixelstats/pixelatoms.proto @@ -19,15 +19,18 @@ syntax = "proto2"; // C++ namespace: android::hardware::google::pixel::PixelAtoms package android.hardware.google.pixel.PixelAtoms; +option optimize_for = LITE_RUNTIME; + option java_package = "android.hardware.google.pixel"; option java_outer_classname = "PixelAtoms"; +import "frameworks/proto_logging/stats/atom_field_options.proto"; + /* * Please note that the following features are not currently supported by * the IStats->reportVendorAtom implementation: - * - types outside of int, long, float, and string (ex. uint) + * - types outside of int, long, float, bool and string (ex. uint) * - submessages within an atom - * - repeated fields - arrays must be unrolled * - field # 1 - this will be occupied by the vendor namespace */ @@ -43,8 +46,7 @@ message Atom { ZramMmStat zram_mm_stat = 105005; ZramBdStat zram_bd_stat = 105006; BootStatsInfo boot_stats = 105007; - WirelessChargingStats wireless_charging_stats = 105008; - DeviceOrientation device_orientation = 105009; + // 105008 - 105009 is available. BatteryCapacityFG fg_capacity = 105010; PdVidPid pd_vid_pid = 105011; BatteryEEPROM battery_eeprom = 105012; @@ -61,8 +63,10 @@ message Atom { VendorUsbPortOverheat vendor_usb_port_overheat = 105023; // moved from atoms.proto CmaStatus cma_status = 105024; CmaStatusExt cma_status_ext = 105025; - VendorBatteryHealthSnapshot vendor_battery_health_snapshot = 105026; // moved from atoms.proto - VendorBatteryCausedShutdown vendor_battery_caused_shutdown = 105027; // moved from atoms.proto + VendorBatteryHealthSnapshot vendor_battery_health_snapshot = + 105026 [(android.os.statsd.module) = "pixelhealth"]; // moved from atoms.proto + VendorBatteryCausedShutdown vendor_battery_caused_shutdown = + 105027 [(android.os.statsd.module) = "pixelhealth"]; // moved from atoms.proto F2fsGcSegmentInfo f2fs_gc_segment_info = 105028; PowerMitigationStats mitigation_stats = 105029; // moved from atoms.proto @@ -70,17 +74,42 @@ message Atom { CitadelEvent citadel_event = 100019; // moved from vendor proprietary VendorSpeakerStatsReported vendor_speaker_stats_reported = 105030; - ChreHalNanoappLoadFailed chre_hal_nanoapp_load_failed = 105031; - ChrePalOpenFailed chre_pal_open_failed = 105032; - ChreApiErrorCodeDistributionTaken chre_api_error_code_distribution_taken = 105033; - ChreDynamicMemorySnapshotReported chre_dynamic_memory_snapshot_reported = 105034; - ChreEventQueueSnapshotReported chre_event_queue_snapshot_reported = 105035; - ChreApWakeUpOccurred chre_ap_wake_up_occurred = 105036; + ChreHalNanoappLoadFailed chre_hal_nanoapp_load_failed = + 105031 [(android.os.statsd.module) = "chre"]; + ChrePalOpenFailed chre_pal_open_failed = 105032 [(android.os.statsd.module) = "chre"]; + ChreApiErrorCodeDistributionTaken chre_api_error_code_distribution_taken = + 105033 [(android.os.statsd.module) = "chre"]; + ChreDynamicMemorySnapshotReported chre_dynamic_memory_snapshot_reported = + 105034 [(android.os.statsd.module) = "chre"]; + ChreEventQueueSnapshotReported chre_event_queue_snapshot_reported = + 105035 [(android.os.statsd.module) = "chre"]; + ChreApWakeUpOccurred chre_ap_wake_up_occurred = 105036 [(android.os.statsd.module) = "chre"]; BatteryHealthStatus battery_health_status = 105037; BatteryHealthUsage battery_health_usage = 105038; + F2fsSmartIdleMaintEnabledStateChanged f2fs_smart_idle_maint_enabled_state_changed = 105039; + BlockStatsReported block_stats_reported = 105040; + VendorAudioHardwareStatsReported vendor_audio_hardware_stats_reported = 105041; + + ThermalDfsStats thermal_dfs_stats = 105042; + VendorLongIRQStatsReported vendor_long_irq_stats_reported = 105043; + VendorResumeLatencyStats vendor_resume_latency_stats = 105044; + VendorTempResidencyStats vendor_temp_residency_stats = 105045; + BrownoutDetected brownout_detected = 105046; + PcieLinkStatsReported pcie_link_stats = 105047; + VendorSensorCoolingDeviceStats vendor_sensor_cooling_device_stats = 105048; + + VibratorPlaycountReported vibrator_playcount_reported = 105049; + VibratorLatencyReported vibrator_latency_reported = 105050; + VibratorErrorsReported vibrator_errors_reported = 105051; + + F2fsAtomicWriteInfo f2fs_atomic_write_info = 105052; + PartitionsUsedSpaceReported partition_used_space_reported = 105053; } // AOSP atom ID range ends at 109999 + reserved 109997; // reserved for VtsVendorAtomJavaTest test atom + reserved 109998; // reserved for VtsVendorAtomJavaTest test atom + reserved 109999; // reserved for VtsVendorAtomJavaTest test atom } /* Supported reverse domain names. */ @@ -118,6 +147,10 @@ message ChargeStats { ADAPTER_TYPE_WPC_10W = 23; ADAPTER_TYPE_WPC_BPP = 24; ADAPTER_TYPE_WPC_L7 = 25; + ADAPTER_TYPE_EXT = 26; + ADAPTER_TYPE_EXT1 = 27; + ADAPTER_TYPE_EXT2 = 28; + ADAPTER_TYPE_EXT_UNKNOWN = 29; } optional string reverse_domain_name = 1; /* Type of charge adapter, enumerated above. */ @@ -419,6 +452,7 @@ message CitadelEvent { REBOOTED = 2; UPGRADED = 3; ALERT_V2 = 4; + SEC_CH_STATE = 5; }; optional string reverse_domain_name = 1; optional Event event = 2; @@ -462,6 +496,10 @@ message CitadelEvent { optional int32 temp_min = 20; optional int32 temp_max = 21; optional int32 bus_err = 22; + + // SEC_CH_STATE-specific filed. This field corresponds to the state + // of GSA-GSC secure channel. + optional int32 sec_ch_state = 23; } /* A message containing the citadel firmware version. */ @@ -514,12 +552,63 @@ message PixelMmMetricsPerHour { optional int64 unevictable = 7; optional int64 ion_total_pools = 8; optional int64 gpu_memory = 9; + optional int64 slab_unreclaimable = 10; + optional int64 psi_cpu_some_total = 11; + optional int64 psi_io_full_total = 12; + optional int64 psi_io_some_total = 13; + optional int64 psi_mem_full_total = 14; + optional int64 psi_mem_some_total = 15; + optional int32 psi_cpu_some_avg10_min = 16; + optional int32 psi_cpu_some_avg10_max = 17; + optional int32 psi_cpu_some_avg10_avg = 18; + optional int32 psi_cpu_some_avg60_min = 19; + optional int32 psi_cpu_some_avg60_max = 20; + optional int32 psi_cpu_some_avg60_avg = 21; + optional int32 psi_cpu_some_avg300_min = 22; + optional int32 psi_cpu_some_avg300_max = 23; + optional int32 psi_cpu_some_avg300_avg = 24; + optional int32 psi_io_full_avg10_min = 25; + optional int32 psi_io_full_avg10_max = 26; + optional int32 psi_io_full_avg10_avg = 27; + optional int32 psi_io_full_avg60_min = 28; + optional int32 psi_io_full_avg60_max = 29; + optional int32 psi_io_full_avg60_avg = 30; + optional int32 psi_io_full_avg300_min = 31; + optional int32 psi_io_full_avg300_max = 32; + optional int32 psi_io_full_avg300_avg = 33; + optional int32 psi_io_some_avg10_min = 34; + optional int32 psi_io_some_avg10_max = 35; + optional int32 psi_io_some_avg10_avg = 36; + optional int32 psi_io_some_avg60_min = 37; + optional int32 psi_io_some_avg60_max = 38; + optional int32 psi_io_some_avg60_avg = 39; + optional int32 psi_io_some_avg300_min = 40; + optional int32 psi_io_some_avg300_max = 41; + optional int32 psi_io_some_avg300_avg = 42; + optional int32 psi_mem_full_avg10_min = 43; + optional int32 psi_mem_full_avg10_max = 44; + optional int32 psi_mem_full_avg10_avg = 45; + optional int32 psi_mem_full_avg60_min = 46; + optional int32 psi_mem_full_avg60_max = 47; + optional int32 psi_mem_full_avg60_avg = 48; + optional int32 psi_mem_full_avg300_min = 49; + optional int32 psi_mem_full_avg300_max = 50; + optional int32 psi_mem_full_avg300_avg = 51; + optional int32 psi_mem_some_avg10_min = 52; + optional int32 psi_mem_some_avg10_max = 53; + optional int32 psi_mem_some_avg10_avg = 54; + optional int32 psi_mem_some_avg60_min = 55; + optional int32 psi_mem_some_avg60_max = 56; + optional int32 psi_mem_some_avg60_avg = 57; + optional int32 psi_mem_some_avg300_min = 58; + optional int32 psi_mem_some_avg300_max = 59; + optional int32 psi_mem_some_avg300_avg = 60; } /* A message containing Pixel memory metrics collected daily. */ message PixelMmMetricsPerDay { optional string reverse_domain_name = 1; - optional int64 workingset_refault = 2; + optional int64 workingset_refault = 2; /* refault_file */ optional int64 pswpin = 3; optional int64 pswpout = 4; optional int64 allocstall_dma = 5; @@ -540,6 +629,43 @@ message PixelMmMetricsPerDay { optional int64 pgcache_miss = 20; optional int64 kswapd_stime_clks = 21; optional int64 kcompactd_stime_clks = 22; + optional int64 direct_reclaim_native_latency_total_time = 23; + optional int64 direct_reclaim_native_latency0 = 24; + optional int64 direct_reclaim_native_latency1 = 25; + optional int64 direct_reclaim_native_latency2 = 26; + optional int64 direct_reclaim_native_latency3 = 27; + optional int64 direct_reclaim_visible_latency_total_time = 28; + optional int64 direct_reclaim_visible_latency0 = 29; + optional int64 direct_reclaim_visible_latency1 = 30; + optional int64 direct_reclaim_visible_latency2 = 31; + optional int64 direct_reclaim_visible_latency3 = 32; + optional int64 direct_reclaim_top_latency_total_time = 33; + optional int64 direct_reclaim_top_latency0 = 34; + optional int64 direct_reclaim_top_latency1 = 35; + optional int64 direct_reclaim_top_latency2 = 36; + optional int64 direct_reclaim_top_latency3 = 37; + optional int64 direct_reclaim_other_latency_total_time = 38; + optional int64 direct_reclaim_other_latency0 = 39; + optional int64 direct_reclaim_other_latency1 = 40; + optional int64 direct_reclaim_other_latency2 = 41; + optional int64 direct_reclaim_other_latency3 = 42; + optional int64 compaction_total_time = 43; + optional int64 compaction_ev_count0 = 44; + optional int64 compaction_ev_count1 = 45; + optional int64 compaction_ev_count2 = 46; + optional int64 compaction_ev_count3 = 47; + optional int64 compaction_ev_count4 = 48; + optional int64 workingset_refault_anon = 49; + optional int64 workingset_refault_file = 50; + optional int64 compact_success = 51; + optional int64 compact_fail = 52; + optional int64 kswapd_low_wmark_hq = 53; + optional int64 kswapd_high_wmark_hq = 54; + optional int64 thp_file_alloc = 55; + optional int64 thp_zero_page_alloc = 56; + optional int64 thp_split_page = 57; + optional int64 thp_migration_split = 58; + optional int64 thp_deferred_split_page = 59; } /* A message containing CMA metrics collected from dogfooding only. */ @@ -803,6 +929,25 @@ message PowerMitigationStats { } /** + * Log thermal statistics. + */ +message ThermalDfsStats { + optional string reverse_domain_name = 1; + // The last count of BIG cluster dfs triggers + optional int32 big_dfs_count = 2; + // The last count of MID cluster dfs triggers + optional int32 mid_dfs_count = 3; + // The last count of LITTLE cluster dfs triggers + optional int32 little_dfs_count = 4; + // The last count of GPU dfs triggers + optional int32 gpu_dfs_count = 5; + // The last count of TPU dfs triggers + optional int32 tpu_dfs_count = 6; + // The last count of DSP dfs triggers + optional int32 aur_dfs_count = 7; +} + +/** * Log how many segments have been reclaimed in a specific GC mode. */ message F2fsGcSegmentInfo { @@ -813,6 +958,8 @@ message F2fsGcSegmentInfo { optional int32 reclaimed_segments_urgent_high = 3; /* Reclaimed segments in GC urgent low mode */ optional int32 reclaimed_segments_urgent_low = 4; + /* Reclaimed segments in GC urgent mid mode */ + optional int32 reclaimed_segments_urgent_mid = 5; } /** @@ -1035,11 +1182,13 @@ message BatteryHealthStatus { optional int32 health_algorithm = 2; enum HealthStatus { - UNKNOWN = 0; // The health status is unknown due to a SW limitation or issue - NOMINAL = 1; // The battery is operating as expected - MARGINAL = 2; // The battery may need replacement soon - NEEDS_REPLACEMENT = 3; // The battery needs replacement - FAILED = 4; // The battery has failed and no longer operates as expected + UNKNOWN = -1; // The health status is unknown due to a SW limitation or issue + NOMINAL = 0; // The battery is operating as expected + MARGINAL = 1; // The battery may need replacement soon + NEEDS_REPLACEMENT = 2; // The battery needs replacement + FAILED = 3; // The battery has failed and no longer operates as expected + NOT_AVAILABLE = 4; // This is a temporary state when cycle count is insufficient + INCONSISTENT = 5; // The battery recalibration is pending } // HealthStatus calculated using health_index, health_perf_index. @@ -1068,6 +1217,16 @@ message BatteryHealthStatus { // The cycle count at the time of the log event. optional int32 cycle_count = 11; + + enum BattDisconnectStatus { + BPST_BATT_UNKNOWN = 0; + BPST_BATT_CONNECT = 1; + BPST_BATT_DISCONNECT = 2; // Result of single battery disconnect detection + BPST_BATT_CELL_FAULT = 3; // Result of cell fault detection which means actual disconnection + } + + // Battery disconnect detection stats. + optional BattDisconnectStatus battery_disconnect_status = 12; } /** @@ -1096,3 +1255,482 @@ message BatteryHealthUsage { // Time (s) accumulated only during discharge at the given thresholds. optional int32 discharge_time_secs = 5; } + +/* + * A Value of F2FS smart idle maintenance feature enabled + */ +message F2fsSmartIdleMaintEnabledStateChanged { + optional string reverse_domain_name = 1; + /* Smart idle maint is enabled */ + optional bool enabled = 2; +} + +/* + * Snapshot of the block layer read write stats + */ +message BlockStatsReported { + optional string reverse_domain_name = 1; + /* number of read I/Os processed */ + optional int64 read_io = 2; + /* number of sectors read */ + optional int64 read_sectors = 3; + /* total wait time for read requests */ + optional int64 read_ticks = 4; + /* number of write I/Os processed */ + optional int64 write_io = 5; + /* number of sectors written */ + optional int64 write_sectors = 6; + /* total wait time for write requests */ + optional int64 write_ticks = 7; +} + +/** + * Logs the reported vendor audio hardware stats. + */ +message VendorAudioHardwareStatsReported { + optional string reverse_domain_name = 1; + /* The percentage of calls in a day where auto-mic-switch triggered. + * It represented as a fixed-point integer with three decimal place. + * E.g.:12.345% is repsented by 12345. + */ + optional int32 milli_rate_of_ams_per_day = 2; + + /* The percentage of calls in a day where CCA is active. + * It represented as a fixed-point and rounded integer. + * E.g.:12.345% is represented by 12. + * CCA can only be applied under some radio bands. + */ + + /* cca_active: UI enable & algorithm is active (C1) */ + optional int32 rate_of_cca_active_per_day = 3; + + /* cca_enable: UI enable & algorithm is inactive. (C2) */ + optional int32 rate_of_cca_enable_per_day = 4; +} + +/* + * Logs vendor stats about long IRQs. + * + * IRQ is considered long when it exceeds a threshold (currently 1 ms). + * Stats include top 5 slowest IRQs: their numbers and the worst latency. + * Stats are reset after every report. + */ +message VendorLongIRQStatsReported { + optional string reverse_domain_name = 1; + + // Count of long soft IRQ since last report. + optional int64 long_softirq_count = 2; + + optional int64 top1_softirq_num = 3; + optional int64 top1_softirq_latency_us = 4; + optional int64 top2_softirq_num = 5; + optional int64 top2_softirq_latency_us = 6; + optional int64 top3_softirq_num = 7; + optional int64 top3_softirq_latency_us = 8; + optional int64 top4_softirq_num = 9; + optional int64 top4_softirq_latency_us = 10; + optional int64 top5_softirq_num = 11; + optional int64 top5_softirq_latency_us = 12; + + // Count of long IRQ since last report. + optional int64 long_irq_count = 13; + + optional int64 top1_irq_num = 14; + optional int64 top1_irq_latency_us = 15; + optional int64 top2_irq_num = 16; + optional int64 top2_irq_latency_us = 17; + optional int64 top3_irq_num = 18; + optional int64 top3_irq_latency_us = 19; + optional int64 top4_irq_num = 20; + optional int64 top4_irq_latency_us = 21; + optional int64 top5_irq_num = 22; + optional int64 top5_irq_latency_us = 23; +} + +/** + * Logs the Temperature residency stats per thermal zone. + */ +message VendorTempResidencyStats { + optional string reverse_domain_name = 1; + // Thermal zone name + optional string sensor_name = 2; + + // Time since last collect of this thermal zone + optional int64 since_last_update_ms = 3; + + // Temperature residency stats is measured by time in ms that a temperature zone's temperature + // lay within some temperature thresholds + // e.g. + // With temperature thresholds predefined as thresholds_i, thresholds_i+1, + // temp_residency_ms_bucket_i measures how much time the sensor lay within this two thresholds + optional int64 temp_residency_ms_bucket_1 = 4; + optional int64 temp_residency_ms_bucket_2 = 5; + optional int64 temp_residency_ms_bucket_3 = 6; + optional int64 temp_residency_ms_bucket_4 = 7; + optional int64 temp_residency_ms_bucket_5 = 8; + optional int64 temp_residency_ms_bucket_6 = 9; + optional int64 temp_residency_ms_bucket_7 = 10; + optional int64 temp_residency_ms_bucket_8 = 11; + optional int64 temp_residency_ms_bucket_9 = 12; + optional int64 temp_residency_ms_bucket_10 = 13; + optional int64 temp_residency_ms_bucket_11 = 14; + optional int64 temp_residency_ms_bucket_12 = 15; + optional int64 temp_residency_ms_bucket_13 = 16; + optional int64 temp_residency_ms_bucket_14 = 17; + optional int64 temp_residency_ms_bucket_15 = 18; + optional int64 temp_residency_ms_bucket_16 = 19; + optional int64 temp_residency_ms_bucket_17 = 20; + optional int64 temp_residency_ms_bucket_18 = 21; + optional int64 temp_residency_ms_bucket_19 = 22; + optional int64 temp_residency_ms_bucket_20 = 23; + + // The maximum and minimum temperature observed for the sensor along with the + // timestamp of occurrence in terms of time_t. + optional float max_temp = 24; + optional int64 max_temp_timestamp = 25; + optional float min_temp = 26; + optional int64 min_temp_timestamp = 27; +} + +/** + * Logs the Resume Latency stats. + */ +message VendorResumeLatencyStats { + optional string reverse_domain_name = 1; + optional int64 max_latency_ms = 2; + optional int64 avg_latency_ms = 3; + + // Resume Latency stats is measured by count of resumes that lay within some latency thresholds + // e.g. + // With resume times thresholds predefined as thresholds_i, thresholds_i+1, + // resume_count_bucket_i measures count of resumes that lay within this two thresholds + optional int64 resume_count_bucket_1 = 4; + optional int64 resume_count_bucket_2 = 5; + optional int64 resume_count_bucket_3 = 6; + optional int64 resume_count_bucket_4 = 7; + optional int64 resume_count_bucket_5 = 8; + optional int64 resume_count_bucket_6 = 9; + optional int64 resume_count_bucket_7 = 10; + optional int64 resume_count_bucket_8 = 11; + optional int64 resume_count_bucket_9 = 12; + optional int64 resume_count_bucket_10 = 13; + optional int64 resume_count_bucket_11 = 14; + optional int64 resume_count_bucket_12 = 15; + optional int64 resume_count_bucket_13 = 16; + optional int64 resume_count_bucket_14 = 17; + optional int64 resume_count_bucket_15 = 18; + optional int64 resume_count_bucket_16 = 19; + optional int64 resume_count_bucket_17 = 20; + optional int64 resume_count_bucket_18 = 21; + optional int64 resume_count_bucket_19 = 22; + optional int64 resume_count_bucket_20 = 23; + optional int64 resume_count_bucket_21 = 24; + optional int64 resume_count_bucket_22 = 25; + optional int64 resume_count_bucket_23 = 26; + optional int64 resume_count_bucket_24 = 27; + optional int64 resume_count_bucket_25 = 28; + optional int64 resume_count_bucket_26 = 29; + optional int64 resume_count_bucket_27 = 30; + optional int64 resume_count_bucket_28 = 31; + optional int64 resume_count_bucket_29 = 32; + optional int64 resume_count_bucket_30 = 33; + optional int64 resume_count_bucket_31 = 34; + optional int64 resume_count_bucket_32 = 35; + optional int64 resume_count_bucket_33 = 36; + optional int64 resume_count_bucket_34 = 37; + optional int64 resume_count_bucket_35 = 38; + optional int64 resume_count_bucket_36 = 39; +} + +/* + * Log the Brownout events. + */ +message BrownoutDetected { + enum IRQType { + UVLO1 = 0; + SMPL_WARN = 1; + UVLO2 = 2; + BATOILO = 3; + } + + enum BrownoutReason { + UNKNOWN = 0; + UVLO_IF = 1; + OCP_IF = 2; + UVLO_MAIN = 3; + UVLO_SUB = 4; + OCP_B1M = 5; + OCP_B2M = 6; + OCP_B3M = 7; + OCP_B4M = 8; + OCP_B5M = 9; + OCP_B6M = 10; + OCP_B7M = 11; + OCP_B8M = 12; + OCP_B9M = 13; + OCP_B10M = 14; + OCP_B1S = 15; + OCP_B2S = 16; + OCP_B3S = 17; + OCP_B4S = 18; + OCP_B5S = 19; + OCP_B6S = 20; + OCP_B7S = 21; + OCP_B8S = 22; + OCP_B9S = 23; + OCP_B10S = 24; + OCP_BAS = 25; + OCP_BBS = 26; + OCP_BCS = 27; + OCP_BDS = 28; + } + + // Reverse domain name. (e.g. Pixel) + optional string reverse_domain_name = 1; + // Triggered mitigation IRQ + optional IRQType triggered_irq = 2; + // Triggered timestamp + optional int64 triggered_timestamp = 3; + // Triggered battery temperature + optional int32 battery_temp = 4; + // Triggered battery age + optional int32 battery_cycle = 5; + // Triggered battery soc + optional int32 battery_soc = 6; + // Triggered FG Reading: Voltage Now + optional int32 voltage_now = 7; + // Triggered ODPM Reading: Channel 1 + optional int32 odpm_channel01 = 8; + // Triggered ODPM Reading: Channel 2 + optional int32 odpm_channel02 = 9; + // Triggered ODPM Reading: Channel 3 + optional int32 odpm_channel03 = 10; + // Triggered ODPM Reading: Channel 4 + optional int32 odpm_channel04 = 11; + // Triggered ODPM Reading: Channel 5 + optional int32 odpm_channel05 = 12; + // Triggered ODPM Reading: Channel 6 + optional int32 odpm_channel06 = 13; + // Triggered ODPM Reading: Channel 7 + optional int32 odpm_channel07 = 14; + // Triggered ODPM Reading: Channel 8 + optional int32 odpm_channel08 = 15; + // Triggered ODPM Reading: Channel 9 + optional int32 odpm_channel09 = 16; + // Triggered ODPM Reading: Channel 10 + optional int32 odpm_channel10 = 17; + // Triggered ODPM Reading: Channel 11 + optional int32 odpm_channel11 = 18; + // Triggered ODPM Reading: Channel 12 + optional int32 odpm_channel12 = 19; + // Triggered ODPM Reading: Channel 13 + optional int32 odpm_channel13 = 20; + // Triggered ODPM Reading: Channel 14 + optional int32 odpm_channel14 = 21; + // Triggered ODPM Reading: Channel 15 + optional int32 odpm_channel15 = 22; + // Triggered ODPM Reading: Channel 16 + optional int32 odpm_channel16 = 23; + // Triggered ODPM Reading: Channel 17 + optional int32 odpm_channel17 = 24; + // Triggered ODPM Reading: Channel 18 + optional int32 odpm_channel18 = 25; + // Triggered ODPM Reading: Channel 19 + optional int32 odpm_channel19 = 26; + // Triggered ODPM Reading: Channel 20 + optional int32 odpm_channel20 = 27; + // Triggered ODPM Reading: Channel 21 + optional int32 odpm_channel21 = 28; + // Triggered ODPM Reading: Channel 22 + optional int32 odpm_channel22 = 29; + // Triggered ODPM Reading: Channel 23 + optional int32 odpm_channel23 = 30; + // Triggered ODPM Reading: Channel 24 + optional int32 odpm_channel24 = 31; + // Triggered DVFS State: Channel 1 + optional int32 dvfs_channel1 = 32; + // Triggered DVFS State: Channel 2 + optional int32 dvfs_channel2 = 33; + // Triggered DVFS State: Channel 3 + optional int32 dvfs_channel3 = 34; + // Triggered DVFS State: Channel 4 + optional int32 dvfs_channel4 = 35; + // Triggered DVFS State: Channel 5 + optional int32 dvfs_channel5 = 36; + // Triggered DVFS State: Channel 6 + optional int32 dvfs_channel6 = 37; + // brownout reason + optional int32 brownout_reason = 38; +} + +/* + * PCIe Link Statistics + */ +message PcieLinkStatsReported { + /* Vendor reverse domain name (expecting "com.google.pixel"). */ + optional string reverse_domain_name = 1; + + /* Count of new PCIe Link Down events on the modem interface */ + optional int32 modem_pcie_linkdowns = 2; + /* Count of new PCIe Completion Timeout events on the modem interface */ + optional int32 modem_pcie_completion_timeouts = 3; + /* Count of new PCIe Link Up Failure events on the modem interface */ + optional int32 modem_pcie_linkup_failures = 4; + /* Average pll lock time (uS) during PCIe Link Up on modem interface */ + optional int32 modem_pcie_pll_lock_avg = 5; + /* Average time (uS) for successful PCIe Link Up on modem interface */ + optional int32 modem_pcie_link_up_avg = 6; + + /* Count of new PCIe Link Down events on the wifi interface */ + optional int32 wifi_pcie_linkdowns = 7; + /* Count of new PCIe Completion Timeout events on the wifi interface */ + optional int32 wifi_pcie_completion_timeouts = 8; + /* Count of new PCIe Link Up Failure events on the wifi interface */ + optional int32 wifi_pcie_linkup_failures = 9; + /* Average pll lock time (uS) during PCIe Link Up on wifi interface */ + optional int32 wifi_pcie_pll_lock_avg = 10; + /* Average time (uS) for successful PCIe Link Up on wifi interface */ + optional int32 wifi_pcie_link_up_avg = 11; + + /* Count of new PCIe Link Recovery Failure events on the modem interface */ + optional int32 modem_pcie_link_recovery_failures = 12; + /* Count of new PCIe Link Recovery Failure events on the wifi interface */ + optional int32 wifi_pcie_link_recovery_failures = 13; +} + +/** + * Log the CDEV request stats per sensor, binded cooling device. + * Logged from: hardware/google/pixel/thermal/utils/thermal_stats_helper.cpp + */ +message VendorSensorCoolingDeviceStats { + optional string reverse_domain_name = 1; + // Sensor name which is making the cooling device request + optional string trigger_sensor_name = 2; + + // Cooling device name for which request is being made + optional string cooling_device_name = 3; + + // Time duration for which stats are recorded + optional int64 since_last_update_ms = 4; + + // Sequence of values corresponding to time spent in each request state + optional int64 time_in_state_ms_bucket_1 = 5; + optional int64 time_in_state_ms_bucket_2 = 6; + optional int64 time_in_state_ms_bucket_3 = 7; + optional int64 time_in_state_ms_bucket_4 = 8; + optional int64 time_in_state_ms_bucket_5 = 9; + optional int64 time_in_state_ms_bucket_6 = 10; + optional int64 time_in_state_ms_bucket_7 = 11; + optional int64 time_in_state_ms_bucket_8 = 12; + optional int64 time_in_state_ms_bucket_9 = 13; + optional int64 time_in_state_ms_bucket_10 = 14; + optional int64 time_in_state_ms_bucket_11 = 15; + optional int64 time_in_state_ms_bucket_12 = 16; + optional int64 time_in_state_ms_bucket_13 = 17; + optional int64 time_in_state_ms_bucket_14 = 18; + optional int64 time_in_state_ms_bucket_15 = 19; + optional int64 time_in_state_ms_bucket_16 = 20; + optional int64 time_in_state_ms_bucket_17 = 21; + optional int64 time_in_state_ms_bucket_18 = 22; + optional int64 time_in_state_ms_bucket_19 = 23; + optional int64 time_in_state_ms_bucket_20 = 24; +} + +/* Log playcount of effects in Vibrator HAL + * + * Logged from: + * hardware/google/pixel/vibrator/ + */ +message VibratorPlaycountReported { + // Vendor reverse domain name (expecting "com.google.pixel"). + optional string reverse_domain_name = 1; + + // Playcount for each primitive + // Each index tracks the count for that index in the waveform + repeated int32 waveform_counts = 2; + + // Playcount for each 50ms range. + // Each index tracks [50ms * i, 50ms * (i + 1)) + repeated int32 duration_counts = 3; +} + +/* Log latency encountered in Vibrator HAL + * + * Logged from: + * hardware/google/pixel/vibrator/ + */ +message VibratorLatencyReported { + // Vendor reverse domain name (expecting "com.google.pixel"). + optional string reverse_domain_name = 1; + + // Minimum latency seen + // 0 Prebaked and primitives + // 1 Composed effects + // 2 PWLE effects + repeated int32 min_latencies = 2; + + // Maximum latency seen + // 0 Prebaked and primitives + // 1 Composed effects + // 2 PWLE effects + repeated int32 max_latencies = 3; + + // Average latency seen + // 0 Prebaked and primitives + // 1 Composed effects + // 2 PWLE effects + repeated int32 avg_latencies = 4; +} + +/* Log errors encountered in Vibrator HAL + * + * Logged from: + * hardware/google/pixel/vibrator/ + */ +message VibratorErrorsReported { + // Vendor reverse domain name (expecting "com.google.pixel"). + optional string reverse_domain_name = 1; + + // Count for each error + // 0 HwAPI Error + // 1 HwCAL Error + // 2 Compose Fail Error + // 3 ALSA Fail Error + // 4 Async Fail Error + // 5 Bad Timeout Error + // 6 Bad Amplitude Error + // 7 Bad Effect Error + // 8 Bad Effect Strength Error + // 9 Bad Primitive Error + // 10 Bad Composite Error + // 11 PWLE Construction Fail Error + // 12 Unsupported Method Error + repeated int32 error_counts = 2; +} + +/* A message containing F2FS Atomic Write information */ +message F2fsAtomicWriteInfo { + /* Vendor reverse domain name (expecting "com.google.pixel"). */ + optional string reverse_domain_name = 1; + /* Show the peak value of total current atomic write block count after boot */ + optional int32 peak_atomic_write = 2; + /* Show the accumulated total committed atomic write block count after boot */ + optional int32 committed_atomic_block = 3; + /* Show the accumulated total revoked atomic write block count after boot */ + optional int32 revoked_atomic_block = 4; +} + +/* A message containing Partition Used Spaced information */ +message PartitionsUsedSpaceReported { + enum Directory { + UNKNOWN = 0; + PERSIST = 1; + } + /* Vendor reverse domain name (expecting "com.google.pixel"). */ + optional string reverse_domain_name = 1; + + /* used space of directory information */ + optional Directory directory = 2; + optional int64 free_bytes = 3; + optional int64 total_bytes = 4; +}
\ No newline at end of file diff --git a/pixelstats/test/Android.bp b/pixelstats/test/Android.bp new file mode 100644 index 00000000..b2eb0ded --- /dev/null +++ b/pixelstats/test/Android.bp @@ -0,0 +1,45 @@ +// Copyright (C) 2022 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. + +package { + default_applicable_licenses: ["Android-Apache-2.0"], +} + +java_test_host { + name: "PixelAtomsTest", + srcs: [ "**/PixelAtomsTest.java" ], + libs: [ + "compatibility-tradefed", + "tradefed", + "truth-prebuilt", + "host-libprotobuf-java-full", + ], + static_libs: [ + "pixelatoms-java_host", + "base-pixel-atoms-test-lib" + ], + test_suites: [ + "general-tests", + ], +} + +java_library_host { + name: "base-pixel-atoms-test-lib", + srcs: ["**/BasePixelAtomsTest.java"], + libs : [ + "truth-prebuilt", + "host-libprotobuf-java-full", + "tradefed", + ], +}
\ No newline at end of file diff --git a/dauntless/android.hardware.strongbox_keystore.xml b/pixelstats/test/AndroidTest.xml index 949cfcf9..a7d8eee7 100644 --- a/dauntless/android.hardware.strongbox_keystore.xml +++ b/pixelstats/test/AndroidTest.xml @@ -1,5 +1,5 @@ <?xml version="1.0" encoding="utf-8"?> -<!-- Copyright (C) 2021 The Android Open Source Project +<!-- Copyright (C) 2022 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. @@ -13,8 +13,8 @@ See the License for the specific language governing permissions and limitations under the License. --> - -<!-- Feature for devices with StrongBox-backed keystore. --> -<permissions> - <feature name="android.hardware.strongbox_keystore" version="100"/> -</permissions> +<configuration description="Runs Tests for PixelAtoms"> + <test class="com.android.tradefed.testtype.HostTest" > + <option name="jar" value="PixelAtomsTest.jar" /> + </test> +</configuration> diff --git a/pixelstats/test/TEST_MAPPING b/pixelstats/test/TEST_MAPPING new file mode 100644 index 00000000..b348cb9c --- /dev/null +++ b/pixelstats/test/TEST_MAPPING @@ -0,0 +1,7 @@ +{ + "presubmit" : [ + { + "name" : "PixelAtomsTest" + } + ] +} diff --git a/pixelstats/test/android/hardware/google/pixel/BasePixelAtomsTest.java b/pixelstats/test/android/hardware/google/pixel/BasePixelAtomsTest.java new file mode 100644 index 00000000..7bbbcb01 --- /dev/null +++ b/pixelstats/test/android/hardware/google/pixel/BasePixelAtomsTest.java @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2022 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. + */ + +package android.hardware.google.pixel; + +import static com.google.common.truth.Truth.assertWithMessage; + +import static org.junit.Assert.fail; + +import com.google.common.collect.ImmutableSet; +import com.google.protobuf.Descriptors; + +public abstract class BasePixelAtomsTest { + + protected abstract ImmutableSet<Integer> getAllowlistedAtoms(); + + protected void doTestPushedAtomsHasReverseDomainName(Descriptors.Descriptor vendorAtoms) { + for (Descriptors.FieldDescriptor field : vendorAtoms.getFields()) { + Descriptors.OneofDescriptor oneOfAtom = field.getContainingOneof(); + if (oneOfAtom == null) { + fail("Atom not declared in a 'oneof' field"); + } + if ("pushed".equals(oneOfAtom.getName())) { + int atomId = field.getNumber(); + if (getAllowlistedAtoms().contains(atomId)) { + continue; + } + if (atomId < 100001 || atomId > 150000) { + fail("Atom id not in vendor range"); + } + String atomName = field.getName(); + assertWithMessage(atomName + " field 1 should not be empty") + .that(field.getMessageType().findFieldByNumber(1)) + .isNotNull(); + assertWithMessage(atomName + "field 1 should be of string type") + .that(field.getMessageType().findFieldByNumber(1).getType()) + .isEqualTo(Descriptors.FieldDescriptor.Type.STRING); + assertWithMessage(atomName + + " should contain reverse_domain_name as field 1.") + .that(field.getMessageType().findFieldByNumber(1).getName()) + .isEqualTo("reverse_domain_name"); + } + } + } +} diff --git a/pixelstats/test/android/hardware/google/pixel/PixelAtomsTest.java b/pixelstats/test/android/hardware/google/pixel/PixelAtomsTest.java new file mode 100644 index 00000000..e8aedecb --- /dev/null +++ b/pixelstats/test/android/hardware/google/pixel/PixelAtomsTest.java @@ -0,0 +1,37 @@ +/* + * Copyright (C) 2022 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. + */ + +package android.hardware.google.pixel; + +import com.google.common.collect.ImmutableSet; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +@RunWith(JUnit4.class) +public final class PixelAtomsTest extends BasePixelAtomsTest { + + @Override + protected ImmutableSet<Integer> getAllowlistedAtoms() { + return ImmutableSet.of(); + } + + @Test + public void testPushedAtomsHasReverseDomainName() { + doTestPushedAtomsHasReverseDomainName(PixelAtoms.Atom.getDescriptor()); + } +} diff --git a/power-libperfmgr/Android.bp b/power-libperfmgr/Android.bp index 7eccf52e..2163954c 100644 --- a/power-libperfmgr/Android.bp +++ b/power-libperfmgr/Android.bp @@ -33,62 +33,6 @@ cc_library { ], } -cc_library { - name: "libadaptivecpu", - proprietary: true, - vendor: true, - srcs: [ - "adaptivecpu/AdaptiveCpu.cpp", - "adaptivecpu/AdaptiveCpuConfig.cpp", - "adaptivecpu/AdaptiveCpuStats.cpp", - "adaptivecpu/CpuFrequencyReader.cpp", - "adaptivecpu/CpuLoadReaderProcStat.cpp", - "adaptivecpu/CpuLoadReaderSysDevices.cpp", - "adaptivecpu/Device.cpp", - "adaptivecpu/KernelCpuFeatureReader.cpp", - "adaptivecpu/Model.cpp", - "adaptivecpu/RealFilesystem.cpp", - "adaptivecpu/ThrottleDecision.cpp", - "adaptivecpu/TimeSource.cpp", - "adaptivecpu/WorkDurationProcessor.cpp", - ], - shared_libs: [ - "android.hardware.power-V3-ndk", - "libbase", - "liblog", - "libperfmgr", - "libutils", - "libcutils", - ], -} - -cc_test { - name: "libadaptivecpu_test", - proprietary: true, - vendor: true, - srcs: [ - "adaptivecpu/tests/AdaptiveCpuConfigTest.cpp", - "adaptivecpu/tests/AdaptiveCpuStatsTest.cpp", - "adaptivecpu/tests/CpuFrequencyReaderTest.cpp", - "adaptivecpu/tests/CpuLoadReaderProcStatTest.cpp", - "adaptivecpu/tests/CpuLoadReaderSysDevicesTest.cpp", - "adaptivecpu/tests/KernelCpuFeatureReaderTest.cpp", - "adaptivecpu/tests/ModelTest.cpp", - "adaptivecpu/tests/WorkDurationProcessorTest.cpp", - ], - static_libs: [ - "libadaptivecpu", - "libgmock", - "android.hardware.power-V3-ndk", - ], - shared_libs: [ - "liblog", - "libbase", - "libcutils", - ], - test_suites: ["device-tests"], -} - // Deprecated, do not use // Use pixel-power-ext for vendor extension cc_library_headers { @@ -104,8 +48,7 @@ cc_binary { vintf_fragments: ["aidl/android.hardware.power-service.pixel.xml"], vendor: true, shared_libs: [ - "android.hardware.power-V3-ndk", - "libadaptivecpu", + "android.hardware.power-V4-ndk", "libbase", "libcutils", "liblog", @@ -115,6 +58,7 @@ cc_binary { "libperfmgr", "libprocessgroup", "pixel-power-ext-V1-ndk", + "libprotobuf-cpp-full", ], srcs: [ "aidl/service.cpp", @@ -124,3 +68,20 @@ cc_binary { "aidl/PowerSessionManager.cpp", ], } + +cc_binary { + name: "sendhint", + vendor: true, + shared_libs: [ + "android.hardware.power-V3-ndk", + "libbase", + "libcutils", + "liblog", + "libutils", + "libbinder_ndk", + "pixel-power-ext-V1-ndk", + ], + srcs: [ + "utilities/sendhint.cc", + ], +} diff --git a/power-libperfmgr/adaptivecpu/AdaptiveCpu.cpp b/power-libperfmgr/adaptivecpu/AdaptiveCpu.cpp deleted file mode 100644 index 0ad96399..00000000 --- a/power-libperfmgr/adaptivecpu/AdaptiveCpu.cpp +++ /dev/null @@ -1,233 +0,0 @@ -/* - * 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 "powerhal-adaptivecpu" -#define ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL) - -#include "AdaptiveCpu.h" - -#include <android-base/file.h> -#include <android-base/logging.h> -#include <android-base/properties.h> -#include <perfmgr/HintManager.h> -#include <sys/resource.h> -#include <utils/Trace.h> - -#include <chrono> -#include <deque> -#include <numeric> - -#include "CpuLoadReaderSysDevices.h" -#include "Model.h" - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -using ::android::perfmgr::HintManager; - -// We pass the previous N ModelInputs to the model, including the most recent ModelInput. -constexpr uint32_t kNumHistoricalModelInputs = 3; - -// TODO(b/207662659): Add config for changing between different reader types. -AdaptiveCpu::AdaptiveCpu() {} - -bool AdaptiveCpu::IsEnabled() const { - return mIsEnabled; -} - -void AdaptiveCpu::HintReceived(bool enable) { - ATRACE_CALL(); - LOG(INFO) << "AdaptiveCpu received hint: enable=" << enable; - if (enable) { - StartThread(); - } else { - SuspendThread(); - } -} - -void AdaptiveCpu::StartThread() { - ATRACE_CALL(); - std::lock_guard lock(mThreadCreationMutex); - LOG(INFO) << "Starting AdaptiveCpu thread"; - mIsEnabled = true; - mShouldReloadConfig = true; - mLastEnabledHintTime = mTimeSource.GetTime(); - if (!mLoopThread.joinable()) { - mLoopThread = std::thread([&]() { - pthread_setname_np(pthread_self(), "AdaptiveCpu"); - // Parent threads may have higher priorities, so we reset to the default. - int ret = setpriority(PRIO_PROCESS, 0, 0); - if (ret != 0) { - PLOG(ERROR) << "setpriority on AdaptiveCpu thread failed: " << ret; - } - LOG(INFO) << "Started AdaptiveCpu thread successfully"; - RunMainLoop(); - LOG(ERROR) << "AdaptiveCpu thread ended, this should never happen!"; - }); - } -} - -void AdaptiveCpu::SuspendThread() { - ATRACE_CALL(); - LOG(INFO) << "Stopping AdaptiveCpu thread"; - // This stops the thread from receiving work durations in ReportWorkDurations, which means the - // thread blocks indefinitely. - mIsEnabled = false; -} - -void AdaptiveCpu::ReportWorkDurations(const std::vector<WorkDuration> &workDurations, - std::chrono::nanoseconds targetDuration) { - ATRACE_CALL(); - if (!mIsEnabled) { - return; - } - if (!mWorkDurationProcessor.ReportWorkDurations(workDurations, targetDuration)) { - mIsEnabled = false; - return; - } - mWorkDurationsAvailableCondition.notify_one(); -} - -void AdaptiveCpu::WaitForEnabledAndWorkDurations() { - ATRACE_CALL(); - std::unique_lock<std::mutex> lock(mWaitMutex); - // TODO(b/188770301) Once the gating logic is implemented, don't block indefinitely. - mWorkDurationsAvailableCondition.wait( - lock, [&] { return mIsEnabled && mWorkDurationProcessor.HasWorkDurations(); }); -} - -void AdaptiveCpu::RunMainLoop() { - ATRACE_CALL(); - - std::deque<ModelInput> historicalModelInputs; - ThrottleDecision previousThrottleDecision = ThrottleDecision::NO_THROTTLE; - while (true) { - ATRACE_NAME("loop"); - WaitForEnabledAndWorkDurations(); - - if (mLastEnabledHintTime + mConfig.enabledHintTimeout < mTimeSource.GetTime()) { - LOG(INFO) << "Adaptive CPU hint timed out, last enabled time=" - << mLastEnabledHintTime.count() << "ns"; - mIsEnabled = false; - continue; - } - - if (mShouldReloadConfig) { - if (!AdaptiveCpuConfig::ReadFromSystemProperties(&mConfig)) { - mIsEnabled = false; - continue; - } - LOG(INFO) << "Read config: " << mConfig; - mShouldReloadConfig = false; - } - - ATRACE_BEGIN("compute"); - mAdaptiveCpuStats.RegisterStartRun(); - - if (!mIsInitialized) { - if (!mKernelCpuFeatureReader.Init()) { - mIsEnabled = false; - continue; - } - mDevice = ReadDevice(); - mIsInitialized = true; - } - - ModelInput modelInput; - modelInput.previousThrottleDecision = previousThrottleDecision; - - modelInput.workDurationFeatures = mWorkDurationProcessor.GetFeatures(); - LOG(VERBOSE) << "Got work durations: count=" << modelInput.workDurationFeatures.numDurations - << ", average=" << modelInput.workDurationFeatures.averageDuration.count() - << "ns"; - if (modelInput.workDurationFeatures.numDurations == 0) { - continue; - } - - if (!mKernelCpuFeatureReader.GetRecentCpuFeatures(&modelInput.cpuPolicyAverageFrequencyHz, - &modelInput.cpuCoreIdleTimesPercentage)) { - mIsEnabled = false; - continue; - } - - modelInput.LogToAtrace(); - historicalModelInputs.push_back(modelInput); - if (historicalModelInputs.size() > kNumHistoricalModelInputs) { - historicalModelInputs.pop_front(); - } - - const ThrottleDecision throttleDecision = mModel.Run(historicalModelInputs, mConfig); - LOG(VERBOSE) << "Model decision: " << static_cast<uint32_t>(throttleDecision); - ATRACE_INT("AdaptiveCpu_throttleDecision", static_cast<uint32_t>(throttleDecision)); - - { - ATRACE_NAME("sendHints"); - const auto now = mTimeSource.GetTime(); - // Resend the throttle hints, even if they've not changed, if the previous send is close - // to timing out. We define "close to" as half the hint timeout, as we can't guarantee - // we will run again before the actual timeout. - const bool throttleHintMayTimeout = - now - mLastThrottleHintTime > mConfig.hintTimeout / 2; - if (throttleDecision != previousThrottleDecision || throttleHintMayTimeout) { - ATRACE_NAME("sendNewHints"); - mLastThrottleHintTime = now; - for (const auto &hintName : THROTTLE_DECISION_TO_HINT_NAMES.at(throttleDecision)) { - HintManager::GetInstance()->DoHint(hintName, mConfig.hintTimeout); - } - } - if (throttleDecision != previousThrottleDecision) { - ATRACE_NAME("endOldHints"); - for (const auto &hintName : - THROTTLE_DECISION_TO_HINT_NAMES.at(previousThrottleDecision)) { - HintManager::GetInstance()->EndHint(hintName); - } - previousThrottleDecision = throttleDecision; - } - } - - mAdaptiveCpuStats.RegisterSuccessfulRun(previousThrottleDecision, throttleDecision, - modelInput.workDurationFeatures, mConfig); - ATRACE_END(); // compute - { - ATRACE_NAME("sleep"); - std::this_thread::sleep_for(mConfig.iterationSleepDuration); - } - } -} - -void AdaptiveCpu::DumpToFd(int fd) const { - std::stringstream result; - result << "========== Begin Adaptive CPU stats ==========\n"; - result << "Enabled: " << mIsEnabled << "\n"; - result << "Config: " << mConfig << "\n"; - mKernelCpuFeatureReader.DumpToStream(result); - mAdaptiveCpuStats.DumpToStream(result); - result << "========== End Adaptive CPU stats ==========\n"; - if (!::android::base::WriteStringToFd(result.str(), fd)) { - PLOG(ERROR) << "Failed to dump state to fd"; - } -} - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/AdaptiveCpu.h b/power-libperfmgr/adaptivecpu/AdaptiveCpu.h deleted file mode 100644 index 4ab83c52..00000000 --- a/power-libperfmgr/adaptivecpu/AdaptiveCpu.h +++ /dev/null @@ -1,112 +0,0 @@ -/* - * 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. - */ - -#pragma once - -#include <aidl/android/hardware/power/WorkDuration.h> -#include <perfmgr/HintManager.h> - -#include <chrono> -#include <thread> -#include <unordered_map> -#include <vector> - -#include "AdaptiveCpuConfig.h" -#include "AdaptiveCpuStats.h" -#include "Device.h" -#include "KernelCpuFeatureReader.h" -#include "Model.h" -#include "WorkDurationProcessor.h" - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -using std::chrono_literals::operator""ms; -using ::aidl::android::hardware::power::WorkDuration; -using ::android::perfmgr::HintManager; - -// Applies CPU frequency hints infered by an ML model based on the recent CPU statistics and work -// durations. -// This class's public members are not synchronised and should not be used from multiple threads, -// with the exception of ReportWorkDuration, which can be called from an arbitrary thread. -class AdaptiveCpu { - public: - AdaptiveCpu(); - - bool IsEnabled() const; - - // Called when the Adaptive CPU hint is received. This method enables/disables the Adaptive CPU - // thread. - void HintReceived(bool enable); - - // Reports work durations for processing. This method returns immediately as work durations are - // processed asynchonuously. - void ReportWorkDurations(const std::vector<WorkDuration> &workDurations, - std::chrono::nanoseconds targetDuration); - - // Dump info to a file descriptor. Called when dumping service info. - void DumpToFd(int fd) const; - - // When PowerExt receives a hint with this name, HintReceived() is called. - static constexpr char HINT_NAME[] = "ADAPTIVE_CPU"; - - private: - void StartThread(); - - void SuspendThread(); - - // The main loop of Adaptive CPU, which runs in a separate thread. - void RunMainLoop(); - - void WaitForEnabledAndWorkDurations(); - - Model mModel; - WorkDurationProcessor mWorkDurationProcessor; - KernelCpuFeatureReader mKernelCpuFeatureReader; - AdaptiveCpuStats mAdaptiveCpuStats; - const TimeSource mTimeSource; - - // The thread in which work durations are processed. - std::thread mLoopThread; - - // Guards against creating multiple threads in the case HintReceived(true) is called on separate - // threads simultaneously. - std::mutex mThreadCreationMutex; - // Used when waiting in WaitForEnabledAndWorkDurations(). - std::mutex mWaitMutex; - - // A condition variable that will be notified when new work durations arrive. - std::condition_variable mWorkDurationsAvailableCondition; - - volatile bool mIsEnabled = false; - bool mIsInitialized = false; - volatile bool mShouldReloadConfig = false; - std::chrono::nanoseconds mLastEnabledHintTime; - std::chrono::nanoseconds mLastThrottleHintTime; - Device mDevice; - AdaptiveCpuConfig mConfig = AdaptiveCpuConfig::DEFAULT; -}; - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/AdaptiveCpuConfig.cpp b/power-libperfmgr/adaptivecpu/AdaptiveCpuConfig.cpp deleted file mode 100644 index 5a8428d1..00000000 --- a/power-libperfmgr/adaptivecpu/AdaptiveCpuConfig.cpp +++ /dev/null @@ -1,174 +0,0 @@ -/* - * Copyright (C) 2022 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 "powerhal-adaptivecpu" -#define ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL) - -#include "AdaptiveCpuConfig.h" - -#include <android-base/logging.h> -#include <android-base/properties.h> -#include <inttypes.h> -#include <utils/Trace.h> - -#include <sstream> -#include <string> -#include <string_view> - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -using std::chrono_literals::operator""ms; -using std::chrono_literals::operator""min; - -constexpr std::string_view kIterationSleepDurationProperty( - "debug.adaptivecpu.iteration_sleep_duration_ms"); -static const std::chrono::milliseconds kIterationSleepDurationMin = 20ms; -constexpr std::string_view kHintTimeoutProperty("debug.adaptivecpu.hint_timeout_ms"); -// "percent" as range is 0-100, while the in-memory is "probability" as range is 0-1. -constexpr std::string_view kRandomThrottleDecisionPercentProperty( - "debug.adaptivecpu.random_throttle_decision_percent"); -constexpr std::string_view kRandomThrottleOptionsProperty( - "debug.adaptivecpu.random_throttle_options"); -constexpr std::string_view kEnabledHintTimeoutProperty("debug.adaptivecpu.enabled_hint_timeout_ms"); - -bool ParseThrottleDecisions(const std::string &input, std::vector<ThrottleDecision> *output); -std::string FormatThrottleDecisions(const std::vector<ThrottleDecision> &throttleDecisions); - -const AdaptiveCpuConfig AdaptiveCpuConfig::DEFAULT{ - // N.B.: The model will typically be trained with this value set to 25ms. We set it to 1s as - // a safety measure, but best performance will be seen at 25ms. - .iterationSleepDuration = 1000ms, - .hintTimeout = 2000ms, - .randomThrottleDecisionProbability = 0, - .randomThrottleOptions = {ThrottleDecision::NO_THROTTLE, ThrottleDecision::THROTTLE_50, - ThrottleDecision::THROTTLE_60, ThrottleDecision::THROTTLE_70, - ThrottleDecision::THROTTLE_80, ThrottleDecision::THROTTLE_90}, - .enabledHintTimeout = 120min, -}; - -bool AdaptiveCpuConfig::ReadFromSystemProperties(AdaptiveCpuConfig *output) { - ATRACE_CALL(); - - output->iterationSleepDuration = std::chrono::milliseconds( - ::android::base::GetUintProperty<uint32_t>(kIterationSleepDurationProperty.data(), - DEFAULT.iterationSleepDuration.count())); - output->iterationSleepDuration = - std::max(output->iterationSleepDuration, kIterationSleepDurationMin); - - output->hintTimeout = std::chrono::milliseconds(::android::base::GetUintProperty<uint32_t>( - kHintTimeoutProperty.data(), DEFAULT.hintTimeout.count())); - - output->randomThrottleDecisionProbability = - static_cast<double>(::android::base::GetUintProperty<uint32_t>( - kRandomThrottleDecisionPercentProperty.data(), - DEFAULT.randomThrottleDecisionProbability * 100)) / - 100; - if (output->randomThrottleDecisionProbability > 1.0) { - LOG(ERROR) << "Received bad value for " << kRandomThrottleDecisionPercentProperty << ": " - << output->randomThrottleDecisionProbability; - return false; - } - - const std::string randomThrottleOptionsStr = - ::android::base::GetProperty(kRandomThrottleOptionsProperty.data(), - FormatThrottleDecisions(DEFAULT.randomThrottleOptions)); - output->randomThrottleOptions.clear(); - if (!ParseThrottleDecisions(randomThrottleOptionsStr, &output->randomThrottleOptions)) { - return false; - } - - output->enabledHintTimeout = - std::chrono::milliseconds(::android::base::GetUintProperty<uint32_t>( - kEnabledHintTimeoutProperty.data(), DEFAULT.enabledHintTimeout.count())); - - return true; -} - -bool AdaptiveCpuConfig::operator==(const AdaptiveCpuConfig &other) const { - return iterationSleepDuration == other.iterationSleepDuration && - hintTimeout == other.hintTimeout && - randomThrottleDecisionProbability == other.randomThrottleDecisionProbability && - enabledHintTimeout == other.enabledHintTimeout && - randomThrottleOptions == other.randomThrottleOptions; -} - -std::ostream &operator<<(std::ostream &stream, const AdaptiveCpuConfig &config) { - stream << "AdaptiveCpuConfig("; - stream << "iterationSleepDuration=" << config.iterationSleepDuration.count() << "ms, "; - stream << "hintTimeout=" << config.hintTimeout.count() << "ms, "; - stream << "randomThrottleDecisionProbability=" << config.randomThrottleDecisionProbability - << ", "; - stream << "enabledHintTimeout=" << config.enabledHintTimeout.count() << "ms, "; - stream << "randomThrottleOptions=[" << FormatThrottleDecisions(config.randomThrottleOptions) - << "]"; - stream << ")"; - return stream; -} - -bool ParseThrottleDecisions(const std::string &input, std::vector<ThrottleDecision> *output) { - std::stringstream ss(input); - while (ss.good()) { - std::string throttleDecisionStr; - if (std::getline(ss, throttleDecisionStr, ',').fail()) { - LOG(ERROR) << "Failed to getline on throttle decisions string: " << input; - return false; - } - uint32_t throttleDecisionInt; - int scanEnd; - if (std::sscanf(throttleDecisionStr.c_str(), "%" PRIu32 "%n", &throttleDecisionInt, - &scanEnd) != 1 || - scanEnd != throttleDecisionStr.size()) { - LOG(ERROR) << "Failed to parse as int: str=" << throttleDecisionStr - << ", input=" << input << ", scanEnd=" << scanEnd; - return false; - } - if (throttleDecisionInt < static_cast<uint32_t>(ThrottleDecision::FIRST) || - throttleDecisionInt > static_cast<uint32_t>(ThrottleDecision::LAST)) { - LOG(ERROR) << "Failed to parse throttle decision: throttleDecision=" - << throttleDecisionInt << ", input=" << input; - return false; - } - output->push_back(static_cast<ThrottleDecision>(throttleDecisionInt)); - } - if (output->empty()) { - LOG(ERROR) << "Failed to find any throttle decisions, must have at least one: " << input; - return false; - } - return true; -} - -std::string FormatThrottleDecisions(const std::vector<ThrottleDecision> &throttleDecisions) { - std::stringstream ss; - for (size_t i = 0; i < throttleDecisions.size(); i++) { - ss << static_cast<uint32_t>(throttleDecisions[i]); - if (i < throttleDecisions.size() - 1) { - ss << ","; - } - } - return ss.str(); -} - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/AdaptiveCpuConfig.h b/power-libperfmgr/adaptivecpu/AdaptiveCpuConfig.h deleted file mode 100644 index 59bef4c9..00000000 --- a/power-libperfmgr/adaptivecpu/AdaptiveCpuConfig.h +++ /dev/null @@ -1,58 +0,0 @@ -/* - * Copyright (C) 2022 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. - */ - -#pragma once - -#include <chrono> -#include <iostream> - -#include "ThrottleDecision.h" - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -struct AdaptiveCpuConfig { - static bool ReadFromSystemProperties(AdaptiveCpuConfig *output); - static const AdaptiveCpuConfig DEFAULT; - - // How long to sleep for between Adaptive CPU runs. - std::chrono::milliseconds iterationSleepDuration; - // Timeout applied to hints. If Adaptive CPU doesn't receive any frames in this time, CPU - // throttling hints are cancelled. - std::chrono::milliseconds hintTimeout; - // Instead of throttling based on model output, choose a random throttle X% of the time. Must be - // between 0 and 1 inclusive. - double randomThrottleDecisionProbability; - std::vector<ThrottleDecision> randomThrottleOptions; - // Setting AdaptiveCpu to enabled only lasts this long. For a continuous run, AdaptiveCpu needs - // to receive the enabled hint more frequently than this value. - std::chrono::milliseconds enabledHintTimeout; - - bool operator==(const AdaptiveCpuConfig &other) const; -}; - -std::ostream &operator<<(std::ostream &os, const AdaptiveCpuConfig &config); - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/AdaptiveCpuStats.cpp b/power-libperfmgr/adaptivecpu/AdaptiveCpuStats.cpp deleted file mode 100644 index 491683b8..00000000 --- a/power-libperfmgr/adaptivecpu/AdaptiveCpuStats.cpp +++ /dev/null @@ -1,131 +0,0 @@ -/* - * 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 "powerhal-adaptivecpu" -#define ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL) - -#include "AdaptiveCpuStats.h" - -#include <utils/Trace.h> - -#include "AdaptiveCpu.h" - -using std::chrono_literals::operator""ns; - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -void AdaptiveCpuStats::RegisterStartRun() { - ATRACE_CALL(); - mNumStartedRuns++; - mLastRunStartTime = mTimeSource->GetTime(); - if (mStartTime == 0ns) { - mStartTime = mLastRunStartTime; - } -} - -void AdaptiveCpuStats::RegisterSuccessfulRun(ThrottleDecision previousThrottleDecision, - ThrottleDecision throttleDecision, - WorkDurationFeatures workDurationFeatures, - const AdaptiveCpuConfig &config) { - ATRACE_CALL(); - mNumSuccessfulRuns++; - mNumThrottles[throttleDecision]++; - const auto runSuccessTime = mTimeSource->GetTime(); - mTotalRunDuration += runSuccessTime - mLastRunStartTime; - // Don't update previousThrottleDecision entries if we haven't run successfully before. - if (mLastRunSuccessTime != 0ns) { - mThrottleDurations[previousThrottleDecision] += - std::min(runSuccessTime - mLastRunSuccessTime, - std::chrono::duration_cast<std::chrono::nanoseconds>(config.hintTimeout)); - mNumDurations[previousThrottleDecision] += workDurationFeatures.numDurations; - mNumMissedDeadlines[previousThrottleDecision] += workDurationFeatures.numMissedDeadlines; - } - mLastRunSuccessTime = runSuccessTime; -} - -void AdaptiveCpuStats::DumpToStream(std::ostream &stream) const { - stream << "Stats:\n"; - stream << "- Successful runs / total runs: " << mNumSuccessfulRuns << " / " << mNumStartedRuns - << "\n"; - stream << "- Total run duration: " << FormatDuration(mTotalRunDuration) << "\n"; - stream << "- Average run duration: " << FormatDuration(mTotalRunDuration / mNumSuccessfulRuns) - << "\n"; - stream << "- Running time fraction: " - << static_cast<double>(mTotalRunDuration.count()) / - (mTimeSource->GetTime() - mStartTime).count() - << "\n"; - - stream << "- Number of throttles:\n"; - size_t totalNumThrottles = 0; - for (const auto &[throttleDecision, numThrottles] : mNumThrottles) { - stream << " - " << ThrottleString(throttleDecision) << ": " << numThrottles << "\n"; - totalNumThrottles += numThrottles; - } - stream << " - Total: " << totalNumThrottles << "\n"; - - stream << "- Time spent throttling:\n"; - std::chrono::nanoseconds totalThrottleDuration; - for (const auto &[throttleDecision, throttleDuration] : mThrottleDurations) { - stream << " - " << ThrottleString(throttleDecision) << ": " - << FormatDuration(throttleDuration) << "\n"; - totalThrottleDuration += throttleDuration; - } - stream << " - Total: " << FormatDuration(totalThrottleDuration) << "\n"; - - stream << "- Missed deadlines per throttle:\n"; - size_t totalNumDurations = 0; - size_t totalNumMissedDeadlines = 0; - for (const auto &[throttleDecision, numDurations] : mNumDurations) { - const size_t numMissedDeadlines = mNumMissedDeadlines.at(throttleDecision); - stream << " - " << ThrottleString(throttleDecision) << ": " << numMissedDeadlines << " / " - << numDurations << " (" << static_cast<double>(numMissedDeadlines) / numDurations - << ")\n"; - totalNumDurations += numDurations; - totalNumMissedDeadlines += numMissedDeadlines; - } - stream << " - Total: " << totalNumMissedDeadlines << " / " << totalNumDurations << " (" - << static_cast<double>(totalNumMissedDeadlines) / totalNumDurations << ")\n"; -} - -std::string AdaptiveCpuStats::FormatDuration(std::chrono::nanoseconds duration) { - double count = static_cast<double>(duration.count()); - std::string suffix; - if (count < 1000.0) { - suffix = "ns"; - } else if (count < 1000.0 * 1000) { - suffix = "us"; - count /= 1000; - } else if (count < 1000.0 * 1000 * 100) { - suffix = "ms"; - count /= 1000 * 1000; - } else { - suffix = "s"; - count /= 1000 * 1000 * 1000; - } - return std::to_string(count) + suffix; -} - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/AdaptiveCpuStats.h b/power-libperfmgr/adaptivecpu/AdaptiveCpuStats.h deleted file mode 100644 index 0c4a7f9f..00000000 --- a/power-libperfmgr/adaptivecpu/AdaptiveCpuStats.h +++ /dev/null @@ -1,73 +0,0 @@ -/* - * 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. - */ - -#pragma once - -#include <ostream> - -#include "AdaptiveCpuConfig.h" -#include "ITimeSource.h" -#include "Model.h" -#include "TimeSource.h" -#include "WorkDurationProcessor.h" - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -// Collects statistics about Adaptive CPU. -// These are only Used during a dumpsys to improve bug report quality. -class AdaptiveCpuStats { - public: - AdaptiveCpuStats() : mTimeSource(std::make_unique<TimeSource>()) {} - AdaptiveCpuStats(std::unique_ptr<ITimeSource> timeSource) - : mTimeSource(std::move(timeSource)) {} - - void RegisterStartRun(); - void RegisterSuccessfulRun(ThrottleDecision previousThrottleDecision, - ThrottleDecision throttleDecision, - WorkDurationFeatures workDurationFeatures, - const AdaptiveCpuConfig &config); - void DumpToStream(std::ostream &stream) const; - - private: - const std::unique_ptr<ITimeSource> mTimeSource; - - size_t mNumStartedRuns = 0; - size_t mNumSuccessfulRuns = 0; - std::chrono::nanoseconds mStartTime; - std::chrono::nanoseconds mLastRunStartTime; - std::chrono::nanoseconds mLastRunSuccessTime; - std::chrono::nanoseconds mTotalRunDuration; - - std::map<ThrottleDecision, size_t> mNumThrottles; - std::map<ThrottleDecision, std::chrono::nanoseconds> mThrottleDurations; - - std::map<ThrottleDecision, size_t> mNumDurations; - std::map<ThrottleDecision, size_t> mNumMissedDeadlines; - - static std::string FormatDuration(std::chrono::nanoseconds duration); -}; - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/CpuFrequencyReader.cpp b/power-libperfmgr/adaptivecpu/CpuFrequencyReader.cpp deleted file mode 100644 index a15d1e36..00000000 --- a/power-libperfmgr/adaptivecpu/CpuFrequencyReader.cpp +++ /dev/null @@ -1,149 +0,0 @@ -/* - * 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 "powerhal-adaptivecpu" -#define ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL) - -#include "CpuFrequencyReader.h" - -#include <android-base/logging.h> -#include <inttypes.h> -#include <utils/Trace.h> - -#include <fstream> -#include <memory> -#include <sstream> - -using std::chrono_literals::operator""ms; - -constexpr std::string_view kCpuPolicyDirectory("/sys/devices/system/cpu/cpufreq"); - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -bool CpuFrequencyReader::Init() { - ATRACE_CALL(); - mCpuPolicyIds.clear(); - if (!ReadCpuPolicyIds(&mCpuPolicyIds)) { - return false; - } - mPreviousCpuPolicyFrequencies.clear(); - return ReadCpuPolicyFrequencies(&mPreviousCpuPolicyFrequencies); -} - -bool CpuFrequencyReader::GetRecentCpuPolicyFrequencies( - std::vector<CpuPolicyAverageFrequency> *result) { - ATRACE_CALL(); - std::map<uint32_t, std::map<uint64_t, std::chrono::milliseconds>> cpuPolicyFrequencies; - if (!ReadCpuPolicyFrequencies(&cpuPolicyFrequencies)) { - return false; - } - for (const auto &[policyId, cpuFrequencies] : cpuPolicyFrequencies) { - const auto &previousCpuFrequencies = mPreviousCpuPolicyFrequencies.find(policyId); - if (previousCpuFrequencies == mPreviousCpuPolicyFrequencies.end()) { - LOG(ERROR) << "Couldn't find policy " << policyId << " in previous frequencies"; - return false; - } - uint64_t weightedFrequenciesSumHz = 0; - std::chrono::milliseconds timeSum = 0ms; - for (const auto &[frequencyHz, time] : cpuFrequencies) { - const auto &previousCpuFrequency = previousCpuFrequencies->second.find(frequencyHz); - if (previousCpuFrequency == previousCpuFrequencies->second.end()) { - LOG(ERROR) << "Couldn't find frequency " << frequencyHz - << " in previous frequencies"; - return false; - } - const std::chrono::milliseconds recentTime = time - previousCpuFrequency->second; - weightedFrequenciesSumHz += frequencyHz * recentTime.count(); - timeSum += recentTime; - } - const uint64_t averageFrequencyHz = - timeSum != 0ms ? weightedFrequenciesSumHz / timeSum.count() : 0; - result->push_back({.policyId = policyId, .averageFrequencyHz = averageFrequencyHz}); - } - mPreviousCpuPolicyFrequencies = cpuPolicyFrequencies; - return true; -} - -std::map<uint32_t, std::map<uint64_t, std::chrono::milliseconds>> -CpuFrequencyReader::GetPreviousCpuPolicyFrequencies() const { - return mPreviousCpuPolicyFrequencies; -} - -bool CpuFrequencyReader::ReadCpuPolicyFrequencies( - std::map<uint32_t, std::map<uint64_t, std::chrono::milliseconds>> *result) { - ATRACE_CALL(); - for (const uint32_t cpuPolicyId : mCpuPolicyIds) { - std::stringstream timeInStatePath; - timeInStatePath << "/sys/devices/system/cpu/cpufreq/policy" << cpuPolicyId - << "/stats/time_in_state"; - std::unique_ptr<std::istream> timeInStateFile; - if (!mFilesystem->ReadFileStream(timeInStatePath.str(), &timeInStateFile)) { - return false; - } - - std::map<uint64_t, std::chrono::milliseconds> cpuFrequencies; - std::string timeInStateLine; - while (std::getline(*timeInStateFile, timeInStateLine)) { - // Time format in time_in_state is 10s of milliseconds: - // https://www.kernel.org/doc/Documentation/cpu-freq/cpufreq-stats.txt - uint64_t frequencyHz, time10Ms; - if (std::sscanf(timeInStateLine.c_str(), "%" PRIu64 " %" PRIu64 "\n", &frequencyHz, - &time10Ms) != 2) { - LOG(ERROR) << "Failed to parse time_in_state line: " << timeInStateLine; - return false; - } - cpuFrequencies[frequencyHz] = time10Ms * 10ms; - } - if (cpuFrequencies.size() > 500) { - LOG(ERROR) << "Found " << cpuFrequencies.size() << " frequencies for policy " - << cpuPolicyId << ", aborting"; - return false; - } - (*result)[cpuPolicyId] = cpuFrequencies; - } - return true; -} - -bool CpuFrequencyReader::ReadCpuPolicyIds(std::vector<uint32_t> *result) const { - ATRACE_CALL(); - std::vector<std::string> entries; - if (!mFilesystem->ListDirectory(kCpuPolicyDirectory.data(), &entries)) { - return false; - } - for (const auto &entry : entries) { - uint32_t cpuPolicyId; - if (!sscanf(entry.c_str(), "policy%d", &cpuPolicyId)) { - continue; - } - result->push_back(cpuPolicyId); - } - // Sort the list, so that getRecentCpuPolicyFrequencies always returns frequencies sorted by - // policy ID. - std::sort(result->begin(), result->end()); - return true; -} - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/CpuFrequencyReader.h b/power-libperfmgr/adaptivecpu/CpuFrequencyReader.h deleted file mode 100644 index ed7a79c9..00000000 --- a/power-libperfmgr/adaptivecpu/CpuFrequencyReader.h +++ /dev/null @@ -1,91 +0,0 @@ -#pragma once - -/* - * 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. - */ - -#include <chrono> -#include <map> -#include <ostream> -#include <set> -#include <vector> - -#include "IFilesystem.h" -#include "RealFilesystem.h" - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -struct CpuPolicyAverageFrequency { - const uint32_t policyId; - const uint64_t averageFrequencyHz; - - bool operator==(const CpuPolicyAverageFrequency &other) const { - return policyId == other.policyId && averageFrequencyHz == other.averageFrequencyHz; - } -}; - -class CpuFrequencyReader { - public: - CpuFrequencyReader() : mFilesystem(std::make_unique<RealFilesystem>()) {} - CpuFrequencyReader(std::unique_ptr<IFilesystem> filesystem) - : mFilesystem(std::move(filesystem)) {} - - // Initialize reading, must be done before calling other methods. - // Work is not done in constructor as it accesses files. - // Returns true on success. - bool Init(); - - // Gets the average frequency each CPU policy was using, since this method was last called. - // Results are returned sorted by policyId. - // Returns true on success. - bool GetRecentCpuPolicyFrequencies(std::vector<CpuPolicyAverageFrequency> *result); - - // The most recently read frequencies for each CPU policy. See readCpuPolicyFrequencies for type - // explanation. Used for dumping to bug reports. - std::map<uint32_t, std::map<uint64_t, std::chrono::milliseconds>> - GetPreviousCpuPolicyFrequencies() const; - - private: - // CPU policy IDs read from /sys. Initialized in #init(). Sorted ascending. - std::vector<uint32_t> mCpuPolicyIds; - // The CPU frequencies when #getRecentCpuPolicyFrequencies was last called (or #init if it has - // not been called yet). - // See readCpuPolicyFrequencies for explanation of type. - std::map<uint32_t, std::map<uint64_t, std::chrono::milliseconds>> mPreviousCpuPolicyFrequencies; - const std::unique_ptr<IFilesystem> mFilesystem; - - // Reads, from the /sys filesystem, the CPU frequencies used by each policy. - // - The outer map's key is the CPU policy ID. - // - The inner map's key is the CPU frequency in Hz. - // - The inner map's value is the time the policy has been running at that frequency, aggregated - // since boot. - // Returns true on success. - bool ReadCpuPolicyFrequencies( - std::map<uint32_t, std::map<uint64_t, std::chrono::milliseconds>> *result); - - bool ReadCpuPolicyIds(std::vector<uint32_t> *result) const; -}; - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/CpuLoadReaderProcStat.cpp b/power-libperfmgr/adaptivecpu/CpuLoadReaderProcStat.cpp deleted file mode 100644 index f91028b9..00000000 --- a/power-libperfmgr/adaptivecpu/CpuLoadReaderProcStat.cpp +++ /dev/null @@ -1,132 +0,0 @@ -/* - * 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 "powerhal-adaptivecpu" -#define ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL) - -#include "CpuLoadReaderProcStat.h" - -#include <android-base/logging.h> -#include <inttypes.h> -#include <utils/Trace.h> - -#include <array> -#include <fstream> -#include <sstream> -#include <string> - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -bool CpuLoadReaderProcStat::Init() { - mPreviousCpuTimes.clear(); - return ReadCpuTimes(&mPreviousCpuTimes); -} - -bool CpuLoadReaderProcStat::GetRecentCpuLoads( - std::array<double, NUM_CPU_CORES> *cpuCoreIdleTimesPercentage) { - ATRACE_CALL(); - if (cpuCoreIdleTimesPercentage == nullptr) { - LOG(ERROR) << "Got nullptr output in getRecentCpuLoads"; - return false; - } - std::map<uint32_t, CpuTime> cpuTimes; - if (!ReadCpuTimes(&cpuTimes)) { - return false; - } - if (cpuTimes.empty()) { - LOG(ERROR) << "Failed to find any CPU times"; - return false; - } - for (const auto &[cpuId, cpuTime] : cpuTimes) { - const auto previousCpuTime = mPreviousCpuTimes.find(cpuId); - if (previousCpuTime == mPreviousCpuTimes.end()) { - LOG(ERROR) << "Couldn't find CPU " << cpuId << " in previous CPU times"; - return false; - } - const auto recentIdleTimeMs = cpuTime.idleTimeMs - previousCpuTime->second.idleTimeMs; - const auto recentTotalTimeMs = cpuTime.totalTimeMs - previousCpuTime->second.totalTimeMs; - if (recentIdleTimeMs > recentTotalTimeMs) { - LOG(ERROR) << "Found more recent idle time than total time: idle=" << recentIdleTimeMs - << ", total=" << recentTotalTimeMs; - return false; - } - const double idleTimePercentage = - static_cast<double>(recentIdleTimeMs) / (recentTotalTimeMs); - LOG(VERBOSE) << "Read CPU idle time: cpuId=" << cpuId - << ", idleTimePercentage=" << idleTimePercentage; - (*cpuCoreIdleTimesPercentage)[cpuId] = idleTimePercentage; - } - mPreviousCpuTimes = cpuTimes; - return true; -} - -bool CpuLoadReaderProcStat::ReadCpuTimes(std::map<uint32_t, CpuTime> *result) { - ATRACE_CALL(); - - std::unique_ptr<std::istream> file; - if (!mFilesystem->ReadFileStream("/proc/stat", &file)) { - return false; - } - std::string line; - ATRACE_BEGIN("loop"); - while (std::getline(*file, line)) { - ATRACE_NAME("parse"); - uint32_t cpuId; - // Times reported when the CPU is active. - uint64_t user, nice, system, irq, softIrq, steal, guest, guestNice; - // Times reported when the CPU is idle. - uint64_t idle, ioWait; - // Order & values taken from `fs/proc/stat.c`. - if (std::sscanf(line.c_str(), - "cpu%d %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 - " %" PRIu64 " %" PRIu64 " %" PRIu64 " %" PRIu64 " ", - &cpuId, &user, &nice, &system, &idle, &ioWait, &irq, &softIrq, &steal, - &guest, &guestNice) != 11) { - continue; - } - uint64_t idleTimeJiffies = idle + ioWait; - uint64_t totalTimeJiffies = - user + nice + system + irq + softIrq + steal + guest + guestNice + idleTimeJiffies; - (*result)[cpuId] = {.idleTimeMs = JiffiesToMs(idleTimeJiffies), - .totalTimeMs = JiffiesToMs(totalTimeJiffies)}; - } - ATRACE_END(); - return true; -} - -void CpuLoadReaderProcStat::DumpToStream(std::stringstream &stream) const { - stream << "CPU loads from /proc/stat:\n"; - for (const auto &[cpuId, cpuTime] : mPreviousCpuTimes) { - stream << "- CPU=" << cpuId << ", idleTime=" << cpuTime.idleTimeMs - << "ms, totalTime=" << cpuTime.totalTimeMs << "ms\n"; - } -} - -uint64_t CpuLoadReaderProcStat::JiffiesToMs(uint64_t jiffies) { - return (jiffies * 1000) / sysconf(_SC_CLK_TCK); -} - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/CpuLoadReaderProcStat.h b/power-libperfmgr/adaptivecpu/CpuLoadReaderProcStat.h deleted file mode 100644 index 81eb3a84..00000000 --- a/power-libperfmgr/adaptivecpu/CpuLoadReaderProcStat.h +++ /dev/null @@ -1,63 +0,0 @@ -#pragma once - -/* - * 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. - */ - -#include <map> - -#include "ICpuLoadReader.h" -#include "IFilesystem.h" -#include "RealFilesystem.h" - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -struct CpuTime { - uint64_t idleTimeMs; - uint64_t totalTimeMs; -}; - -// Reads CPU idle stats from /proc/stat. -class CpuLoadReaderProcStat : public ICpuLoadReader { - public: - CpuLoadReaderProcStat() : mFilesystem(std::make_unique<RealFilesystem>()) {} - CpuLoadReaderProcStat(std::unique_ptr<IFilesystem> filesystem) - : mFilesystem(std::move(filesystem)) {} - - bool Init() override; - bool GetRecentCpuLoads(std::array<double, NUM_CPU_CORES> *cpuCoreIdleTimesPercentage) override; - void DumpToStream(std::stringstream &stream) const override; - - private: - std::map<uint32_t, CpuTime> mPreviousCpuTimes; - const std::unique_ptr<IFilesystem> mFilesystem; - - bool ReadCpuTimes(std::map<uint32_t, CpuTime> *result); - // Converts jiffies to milliseconds. Jiffies is the granularity the kernel reports times in, - // including the timings in CPU statistics. - static uint64_t JiffiesToMs(uint64_t jiffies); -}; - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/CpuLoadReaderSysDevices.cpp b/power-libperfmgr/adaptivecpu/CpuLoadReaderSysDevices.cpp deleted file mode 100644 index 6107997e..00000000 --- a/power-libperfmgr/adaptivecpu/CpuLoadReaderSysDevices.cpp +++ /dev/null @@ -1,151 +0,0 @@ -/* - * 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 "powerhal-adaptivecpu" -#define ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL) - -#include "CpuLoadReaderSysDevices.h" - -#include <android-base/logging.h> -#include <inttypes.h> -#include <utils/Trace.h> - -#include <fstream> -#include <sstream> -#include <string> - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -std::chrono::nanoseconds getKernelTime() { - timespec ts; - clock_gettime(CLOCK_MONOTONIC, &ts); - return std::chrono::nanoseconds(ts.tv_sec * 1000000000UL + ts.tv_nsec); -} - -bool CpuLoadReaderSysDevices::Init() { - mIdleStateNames.clear(); - if (!ReadIdleStateNames(&mIdleStateNames)) { - return false; - } - return ReadCpuTimes(&mPreviousCpuTimes); -} - -bool CpuLoadReaderSysDevices::GetRecentCpuLoads( - std::array<double, NUM_CPU_CORES> *cpuCoreIdleTimesPercentage) { - ATRACE_CALL(); - if (cpuCoreIdleTimesPercentage == nullptr) { - LOG(ERROR) << "Got nullptr output in getRecentCpuLoads"; - return false; - } - std::array<CpuTime, NUM_CPU_CORES> cpuTimes; - if (!ReadCpuTimes(&cpuTimes)) { - return false; - } - if (cpuTimes.empty()) { - LOG(ERROR) << "Failed to find any CPU times"; - return false; - } - for (size_t cpuId = 0; cpuId < NUM_CPU_CORES; cpuId++) { - const auto cpuTime = cpuTimes[cpuId]; - const auto previousCpuTime = mPreviousCpuTimes[cpuId]; - auto recentIdleTime = cpuTime.idleTime - previousCpuTime.idleTime; - const auto recentTotalTime = cpuTime.totalTime - previousCpuTime.totalTime; - if (recentIdleTime > recentTotalTime) { - // This happens occasionally, as we use the idle time from the kernel, and the current - // time from userspace. - recentIdleTime = recentTotalTime; - } - const double idleTimePercentage = - static_cast<double>(recentIdleTime.count()) / recentTotalTime.count(); - (*cpuCoreIdleTimesPercentage)[cpuId] = idleTimePercentage; - } - mPreviousCpuTimes = cpuTimes; - return true; -} - -void CpuLoadReaderSysDevices::DumpToStream(std::stringstream &stream) const { - stream << "CPU loads from /sys/devices/system/cpu/cpuN/cpuidle:\n"; - for (size_t cpuId = 0; cpuId < NUM_CPU_CORES; cpuId++) { - stream << "- CPU=" << cpuId << ", idleTime=" << mPreviousCpuTimes[cpuId].idleTime.count() - << "ms, totalTime=" << mPreviousCpuTimes[cpuId].totalTime.count() << "ms\n"; - } -} - -bool CpuLoadReaderSysDevices::ReadCpuTimes(std::array<CpuTime, NUM_CPU_CORES> *result) const { - ATRACE_CALL(); - const auto totalTime = mTimeSource->GetTime(); - - for (size_t cpuId = 0; cpuId < NUM_CPU_CORES; cpuId++) { - std::chrono::microseconds idleTime; - for (const auto &idleStateName : mIdleStateNames) { - std::stringstream cpuIdlePath; - cpuIdlePath << "/sys/devices/system/cpu/" - << "cpu" << cpuId << "/cpuidle/" << idleStateName << "/time"; - std::unique_ptr<std::istream> file; - if (!mFilesystem->ReadFileStream(cpuIdlePath.str(), &file)) { - return false; - } - // Times are reported in microseconds: - // https://www.kernel.org/doc/Documentation/cpuidle/sysfs.txt - std::string idleTimeUs(std::istreambuf_iterator<char>(*file), {}); - idleTime += std::chrono::microseconds(std::atoi(idleTimeUs.c_str())); - } - (*result)[cpuId] = { - .idleTime = idleTime, - .totalTime = std::chrono::duration_cast<std::chrono::microseconds>(totalTime), - }; - } - - return true; -} - -bool CpuLoadReaderSysDevices::ReadIdleStateNames(std::vector<std::string> *result) const { - std::vector<std::string> idleStateNames; - if (!mFilesystem->ListDirectory("/sys/devices/system/cpu/cpu0/cpuidle", &idleStateNames)) { - return false; - } - for (const auto &idleStateName : idleStateNames) { - if (idleStateName.length() == 0 || idleStateName[0] == '.') { - continue; - } - std::vector<std::string> files; - if (!mFilesystem->ListDirectory( - std::string("/sys/devices/system/cpu/cpu0/cpuidle/") + idleStateName, &files)) { - return false; - } - if (std::find(files.begin(), files.end(), "time") == files.end()) { - continue; - } - result->push_back(idleStateName); - } - if (idleStateNames.empty()) { - LOG(ERROR) << "Found no idle state names"; - return false; - } - return true; -} - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/CpuLoadReaderSysDevices.h b/power-libperfmgr/adaptivecpu/CpuLoadReaderSysDevices.h deleted file mode 100644 index f5022ce0..00000000 --- a/power-libperfmgr/adaptivecpu/CpuLoadReaderSysDevices.h +++ /dev/null @@ -1,71 +0,0 @@ -#pragma once - -/* - * 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. - */ - -#include <chrono> -#include <map> - -#include "ICpuLoadReader.h" -#include "IFilesystem.h" -#include "ITimeSource.h" -#include "Model.h" -#include "RealFilesystem.h" -#include "TimeSource.h" - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -struct CpuTime { - std::chrono::microseconds idleTime; - std::chrono::microseconds totalTime; -}; - -// Reads CPU idle stats from /sys/devices/system/cpu/cpuN/cpuidle. -class CpuLoadReaderSysDevices : public ICpuLoadReader { - public: - CpuLoadReaderSysDevices() - : mFilesystem(std::make_unique<RealFilesystem>()), - mTimeSource(std::make_unique<TimeSource>()) {} - CpuLoadReaderSysDevices(std::unique_ptr<IFilesystem> filesystem, - std::unique_ptr<ITimeSource> timeSource) - : mFilesystem(std::move(filesystem)), mTimeSource(std::move(timeSource)) {} - - bool Init() override; - bool GetRecentCpuLoads(std::array<double, NUM_CPU_CORES> *cpuCoreIdleTimesPercentage) override; - void DumpToStream(std::stringstream &stream) const override; - - private: - const std::unique_ptr<IFilesystem> mFilesystem; - const std::unique_ptr<ITimeSource> mTimeSource; - - std::array<CpuTime, NUM_CPU_CORES> mPreviousCpuTimes; - std::vector<std::string> mIdleStateNames; - - bool ReadCpuTimes(std::array<CpuTime, NUM_CPU_CORES> *result) const; - bool ReadIdleStateNames(std::vector<std::string> *result) const; -}; - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/Device.cpp b/power-libperfmgr/adaptivecpu/Device.cpp deleted file mode 100644 index 54366fbd..00000000 --- a/power-libperfmgr/adaptivecpu/Device.cpp +++ /dev/null @@ -1,55 +0,0 @@ -/* - * Copyright (C) 2022 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 "powerhal-libperfmgr" -#define ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL) - -#include "Device.h" - -#include <android-base/logging.h> -#include <android-base/properties.h> -#include <utils/Trace.h> - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -Device ReadDevice() { - ATRACE_CALL(); - const std::string deviceProperty = ::android::base::GetProperty("ro.product.device", ""); - Device device; - if (deviceProperty == "raven") { - device = Device::RAVEN; - } else if (deviceProperty == "oriole") { - device = Device::ORIOLE; - } else { - LOG(WARNING) << "Failed to parse device property, setting to UNKNOWN: " << deviceProperty; - device = Device::UNKNOWN; - } - LOG(DEBUG) << "Parsed device: deviceProperty=" << deviceProperty - << ", device=" << static_cast<uint32_t>(device); - return device; -} - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/ICpuLoadReader.h b/power-libperfmgr/adaptivecpu/ICpuLoadReader.h deleted file mode 100644 index 62321f75..00000000 --- a/power-libperfmgr/adaptivecpu/ICpuLoadReader.h +++ /dev/null @@ -1,49 +0,0 @@ -#pragma once - -/* - * 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. - */ - -#include <array> -#include <sstream> - -#include "Model.h" - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -class ICpuLoadReader { - public: - // Initialize reading, must be done before calling other methods. - // Work is not done in constructor as it accesses files. - virtual bool Init() = 0; - // Get the load of each CPU, since the last time this method was called. - virtual bool GetRecentCpuLoads( - std::array<double, NUM_CPU_CORES> *cpuCoreIdleTimesPercentage) = 0; - // Dump internal state to a string stream. Used for dumpsys. - virtual void DumpToStream(std::stringstream &stream) const = 0; - virtual ~ICpuLoadReader() {} -}; - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/IFilesystem.h b/power-libperfmgr/adaptivecpu/IFilesystem.h deleted file mode 100644 index 2ec7ad1d..00000000 --- a/power-libperfmgr/adaptivecpu/IFilesystem.h +++ /dev/null @@ -1,49 +0,0 @@ -#pragma once - -/* - * 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. - */ - -#include <chrono> -#include <memory> -#include <ostream> -#include <vector> - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -// Abstracted so we can mock in tests. -class IFilesystem { - public: - virtual ~IFilesystem() {} - virtual bool ListDirectory(const std::string &path, std::vector<std::string> *result) const = 0; - virtual bool ReadFileStream(const std::string &path, - std::unique_ptr<std::istream> *result) const = 0; - // Resets the file stream, so that the next read will read from the beginning. - // This function exists in IFilesystem rather than using istream::seekg directly. This is - // so we can mock this function in tests, allowing us to return different data on reset. - virtual bool ResetFileStream(const std::unique_ptr<std::istream> &fileStream) const = 0; -}; - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/ITimeSource.h b/power-libperfmgr/adaptivecpu/ITimeSource.h deleted file mode 100644 index f2805934..00000000 --- a/power-libperfmgr/adaptivecpu/ITimeSource.h +++ /dev/null @@ -1,41 +0,0 @@ -#pragma once - -/* - * 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. - */ - -#include <chrono> - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -// Abstracted so we can mock in tests. -class ITimeSource { - public: - virtual ~ITimeSource() {} - virtual std::chrono::nanoseconds GetTime() const = 0; - virtual std::chrono::nanoseconds GetKernelTime() const = 0; -}; - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/KernelCpuFeatureReader.cpp b/power-libperfmgr/adaptivecpu/KernelCpuFeatureReader.cpp deleted file mode 100644 index 087f03d9..00000000 --- a/power-libperfmgr/adaptivecpu/KernelCpuFeatureReader.cpp +++ /dev/null @@ -1,135 +0,0 @@ -/* - * Copyright (C) 2022 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 "powerhal-adaptivecpu" -#define ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL) - -#include "KernelCpuFeatureReader.h" - -#include <android-base/logging.h> -#include <utils/Trace.h> - -#include <ostream> - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -constexpr std::string_view kKernelFilePath("/proc/vendor_sched/acpu_stats"); -constexpr size_t kReadBufferSize = sizeof(acpu_stats) * NUM_CPU_CORES; - -bool KernelCpuFeatureReader::Init() { - ATRACE_CALL(); - if (!OpenStatsFile(&mStatsFile)) { - return false; - } - return ReadStats(&mPreviousStats, &mPreviousReadTime); -} - -bool KernelCpuFeatureReader::GetRecentCpuFeatures( - std::array<double, NUM_CPU_POLICIES> *cpuPolicyAverageFrequencyHz, - std::array<double, NUM_CPU_CORES> *cpuCoreIdleTimesPercentage) { - ATRACE_CALL(); - std::array<acpu_stats, NUM_CPU_CORES> stats; - std::chrono::nanoseconds readTime; - if (!ReadStats(&stats, &readTime)) { - return false; - } - const std::chrono::nanoseconds timeDelta = readTime - mPreviousReadTime; - - for (size_t i = 0; i < NUM_CPU_POLICIES; i++) { - // acpu_stats has data per-CPU, but frequency data is equivalent for all CPUs in a policy. - // So, we only read the first CPU in each policy. - const size_t statsIdx = CPU_POLICY_INDICES[i]; - if (stats[statsIdx].weighted_sum_freq < mPreviousStats[statsIdx].weighted_sum_freq) { - LOG(WARNING) << "New weighted_sum_freq is less than old: new=" - << stats[statsIdx].weighted_sum_freq - << ", old=" << mPreviousStats[statsIdx].weighted_sum_freq; - mPreviousStats[statsIdx].weighted_sum_freq = stats[statsIdx].weighted_sum_freq; - } - (*cpuPolicyAverageFrequencyHz)[i] = - static_cast<double>(stats[statsIdx].weighted_sum_freq - - mPreviousStats[statsIdx].weighted_sum_freq) / - timeDelta.count(); - } - for (size_t i = 0; i < NUM_CPU_CORES; i++) { - if (stats[i].total_idle_time_ns < mPreviousStats[i].total_idle_time_ns) { - LOG(WARNING) << "New total_idle_time_ns is less than old: new=" - << stats[i].total_idle_time_ns - << ", old=" << mPreviousStats[i].total_idle_time_ns; - mPreviousStats[i].total_idle_time_ns = stats[i].total_idle_time_ns; - } - (*cpuCoreIdleTimesPercentage)[i] = - static_cast<double>(stats[i].total_idle_time_ns - - mPreviousStats[i].total_idle_time_ns) / - timeDelta.count(); - } - - mPreviousStats = stats; - mPreviousReadTime = readTime; - return true; -} - -bool KernelCpuFeatureReader::OpenStatsFile(std::unique_ptr<std::istream> *file) { - ATRACE_CALL(); - return mFilesystem->ReadFileStream(kKernelFilePath.data(), file); -} - -bool KernelCpuFeatureReader::ReadStats(std::array<acpu_stats, NUM_CPU_CORES> *stats, - std::chrono::nanoseconds *readTime) { - ATRACE_CALL(); - *readTime = mTimeSource->GetKernelTime(); - if (!mFilesystem->ResetFileStream(mStatsFile)) { - return false; - } - char buffer[kReadBufferSize]; - { - ATRACE_NAME("read"); - if (!mStatsFile->read(buffer, kReadBufferSize).good()) { - LOG(ERROR) << "Failed to read stats file"; - return false; - } - } - const size_t bytesRead = mStatsFile->gcount(); - if (bytesRead != kReadBufferSize) { - LOG(ERROR) << "Didn't read full data: expected=" << kReadBufferSize - << ", actual=" << bytesRead; - return false; - } - const auto kernelStructs = reinterpret_cast<acpu_stats *>(buffer); - std::copy(kernelStructs, kernelStructs + NUM_CPU_CORES, stats->begin()); - return true; -} - -void KernelCpuFeatureReader::DumpToStream(std::ostream &stream) const { - ATRACE_CALL(); - stream << "CPU features from acpu_stats:\n"; - for (size_t i = 0; i < NUM_CPU_CORES; i++) { - stream << "- CPU " << i << ": weighted_sum_freq=" << mPreviousStats[i].weighted_sum_freq - << ", total_idle_time_ns=" << mPreviousStats[i].total_idle_time_ns << "\n"; - } - stream << "- Last read time: " << mPreviousReadTime.count() << "ns\n"; -} - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/KernelCpuFeatureReader.h b/power-libperfmgr/adaptivecpu/KernelCpuFeatureReader.h deleted file mode 100644 index bd9e319a..00000000 --- a/power-libperfmgr/adaptivecpu/KernelCpuFeatureReader.h +++ /dev/null @@ -1,83 +0,0 @@ -/* - * Copyright (C) 2022 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. - */ - -#pragma once - -#include <array> -#include <ostream> - -#include "IFilesystem.h" -#include "ITimeSource.h" -#include "Model.h" -#include "RealFilesystem.h" -#include "TimeSource.h" - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -// Kernel <-> Userspace ABI for CPU features. See kernel/sched/acpu.c. -// Contains CPU statistics for a single CPU. The kernel reports an `acpu_stats` struct for each CPU -// on the system. -struct acpu_stats { - // Sum of the CPU frequencies that the CPU used, multiplied by how much time was spent in each - // frequency. Measured in ns*KHz. E.g.: - // 10ns at 100MHz, 2ns at 50MHz = 10*100,000 + 2*50,000 = 1,100,000 - // This is used to calculate the average frequency the CPU was running at between two times: - // (new.weighted_sum_freq - old.weighted_sum_freq) / elapsed_time_ns - uint64_t weighted_sum_freq; - // The total time (in nanoseconds) that the CPU was idle. - // This is ued to calculate the percent of time the CPU was idle between two times: - // (new.total_idle_time_ns - old.total_idle_time_ns) / elapsed_time_ns - uint64_t total_idle_time_ns; -}; - -class KernelCpuFeatureReader { - public: - KernelCpuFeatureReader() - : mFilesystem(std::make_unique<RealFilesystem>()), - mTimeSource(std::make_unique<TimeSource>()) {} - KernelCpuFeatureReader(std::unique_ptr<IFilesystem> filesystem, - std::unique_ptr<ITimeSource> timeSource) - : mFilesystem(std::move(filesystem)), mTimeSource(std::move(timeSource)) {} - - bool Init(); - bool GetRecentCpuFeatures(std::array<double, NUM_CPU_POLICIES> *cpuPolicyAverageFrequencyHz, - std::array<double, NUM_CPU_CORES> *cpuCoreIdleTimesPercentage); - void DumpToStream(std::ostream &stream) const; - - private: - const std::unique_ptr<IFilesystem> mFilesystem; - const std::unique_ptr<ITimeSource> mTimeSource; - // We only open the stats file once and reuse the file descriptor. We find this reduces - // ReadStats runtime by 2x. - std::unique_ptr<std::istream> mStatsFile; - std::array<acpu_stats, NUM_CPU_CORES> mPreviousStats; - std::chrono::nanoseconds mPreviousReadTime; - bool OpenStatsFile(std::unique_ptr<std::istream> *file); - bool ReadStats(std::array<acpu_stats, NUM_CPU_CORES> *stats, - std::chrono::nanoseconds *readTime); -}; - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/Model.cpp b/power-libperfmgr/adaptivecpu/Model.cpp deleted file mode 100644 index ca85d158..00000000 --- a/power-libperfmgr/adaptivecpu/Model.cpp +++ /dev/null @@ -1,106 +0,0 @@ -/* - * 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 "powerhal-adaptivecpu" -#define ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL) - -#include "Model.h" - -#include <android-base/logging.h> -#include <utils/Trace.h> - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -bool ModelInput::SetCpuFreqiencies( - const std::vector<CpuPolicyAverageFrequency> &cpuPolicyAverageFrequencies) { - ATRACE_CALL(); - if (cpuPolicyAverageFrequencies.size() != cpuPolicyAverageFrequencyHz.size()) { - LOG(ERROR) << "Received incorrect amount of CPU policy frequencies, expected " - << cpuPolicyAverageFrequencyHz.size() << ", received " - << cpuPolicyAverageFrequencies.size(); - return false; - } - int32_t previousPolicyId = -1; - for (uint32_t i = 0; i < cpuPolicyAverageFrequencies.size(); i++) { - if (previousPolicyId >= static_cast<int32_t>(cpuPolicyAverageFrequencies[i].policyId)) { - LOG(ERROR) << "CPU frequencies weren't sorted by policy ID, found " << previousPolicyId - << " " << cpuPolicyAverageFrequencies[i].policyId; - return false; - } - previousPolicyId = cpuPolicyAverageFrequencies[i].policyId; - cpuPolicyAverageFrequencyHz[i] = cpuPolicyAverageFrequencies[i].averageFrequencyHz; - } - return true; -} - -void ModelInput::LogToAtrace() const { - if (!ATRACE_ENABLED()) { - return; - } - ATRACE_CALL(); - for (int i = 0; i < cpuPolicyAverageFrequencyHz.size(); i++) { - ATRACE_INT((std::string("ModelInput_frequency_") + std::to_string(i)).c_str(), - static_cast<int>(cpuPolicyAverageFrequencyHz[i])); - } - for (int i = 0; i < cpuCoreIdleTimesPercentage.size(); i++) { - ATRACE_INT((std::string("ModelInput_idle_") + std::to_string(i)).c_str(), - static_cast<int>(cpuCoreIdleTimesPercentage[i] * 100)); - } - ATRACE_INT("ModelInput_workDurations_averageDurationNs", - workDurationFeatures.averageDuration.count()); - ATRACE_INT("ModelInput_workDurations_maxDurationNs", workDurationFeatures.maxDuration.count()); - ATRACE_INT("ModelInput_workDurations_numMissedDeadlines", - workDurationFeatures.numMissedDeadlines); - ATRACE_INT("ModelInput_workDurations_numDurations", workDurationFeatures.numDurations); - ATRACE_INT("ModelInput_prevThrottle", (int)previousThrottleDecision); - ATRACE_INT("ModelInput_device", static_cast<int>(device)); -} - -ThrottleDecision Model::Run(const std::deque<ModelInput> &modelInputs, - const AdaptiveCpuConfig &config) { - ATRACE_CALL(); - if (config.randomThrottleDecisionProbability > 0 && - mShouldRandomThrottleDistribution(mGenerator) < config.randomThrottleDecisionProbability) { - std::uniform_int_distribution<uint32_t> optionDistribution( - 0, config.randomThrottleOptions.size() - 1); - const ThrottleDecision throttleDecision = - config.randomThrottleOptions[optionDistribution(mGenerator)]; - LOG(VERBOSE) << "Randomly overrided throttle decision: " - << static_cast<uint32_t>(throttleDecision); - ATRACE_INT("AdaptiveCpu_randomThrottleDecision", static_cast<uint32_t>(throttleDecision)); - return throttleDecision; - } - ATRACE_INT("AdaptiveCpu_randomThrottleDecision", -1); - return RunDecisionTree(modelInputs); -} - -ThrottleDecision Model::RunDecisionTree(const std::deque<ModelInput> &modelInputs - __attribute__((unused))) { - ATRACE_CALL(); -#include "models/model.inc" -} - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/Model.h b/power-libperfmgr/adaptivecpu/Model.h deleted file mode 100644 index 2a00a8f9..00000000 --- a/power-libperfmgr/adaptivecpu/Model.h +++ /dev/null @@ -1,88 +0,0 @@ -/* - * 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. - */ - -#pragma once - -#include <inttypes.h> - -#include <array> -#include <chrono> -#include <deque> -#include <random> -#include <vector> - -#include "AdaptiveCpuConfig.h" -#include "CpuFrequencyReader.h" -#include "Device.h" -#include "ThrottleDecision.h" -#include "WorkDurationProcessor.h" - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -// Currently Adaptive CPU is targeted to only raven/oriole, so we can hardcode the CPU architecture. -// If we extend to other architectures, this will have to vary per-device or be dynamically loaded. -constexpr uint32_t NUM_CPU_CORES = 8; -constexpr uint32_t NUM_CPU_POLICIES = 3; -constexpr std::array<uint32_t, NUM_CPU_POLICIES> CPU_POLICY_INDICES{0, 4, 6}; - -struct ModelInput { - std::array<double, NUM_CPU_POLICIES> cpuPolicyAverageFrequencyHz; - std::array<double, NUM_CPU_CORES> cpuCoreIdleTimesPercentage; - WorkDurationFeatures workDurationFeatures; - ThrottleDecision previousThrottleDecision; - Device device; - - bool SetCpuFreqiencies( - const std::vector<CpuPolicyAverageFrequency> &cpuPolicyAverageFrequencies); - - void LogToAtrace() const; - - bool operator==(const ModelInput &other) const { - return cpuPolicyAverageFrequencyHz == other.cpuPolicyAverageFrequencyHz && - cpuCoreIdleTimesPercentage == other.cpuCoreIdleTimesPercentage && - workDurationFeatures == other.workDurationFeatures && - previousThrottleDecision == other.previousThrottleDecision; - } -}; - -class Model { - public: - Model() - : mShouldRandomThrottleDistribution(0, 1), - mRandomThrottleDistribution(static_cast<uint32_t>(ThrottleDecision::FIRST), - static_cast<uint32_t>(ThrottleDecision::LAST)) {} - ThrottleDecision Run(const std::deque<ModelInput> &modelInputs, - const AdaptiveCpuConfig &config); - - private: - std::default_random_engine mGenerator; - std::uniform_real_distribution<double> mShouldRandomThrottleDistribution; - std::uniform_int_distribution<uint32_t> mRandomThrottleDistribution; - - ThrottleDecision RunDecisionTree(const std::deque<ModelInput> &modelInputs); -}; - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/RealFilesystem.cpp b/power-libperfmgr/adaptivecpu/RealFilesystem.cpp deleted file mode 100644 index b84796b0..00000000 --- a/power-libperfmgr/adaptivecpu/RealFilesystem.cpp +++ /dev/null @@ -1,76 +0,0 @@ -/* - * 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 "powerhal-adaptivecpu" -#define ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL) - -#include "RealFilesystem.h" - -#include <android-base/logging.h> -#include <dirent.h> -#include <utils/Trace.h> - -#include <fstream> -#include <istream> - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -bool RealFilesystem::ListDirectory(const std::string &path, - std::vector<std::string> *result) const { - ATRACE_CALL(); - // We can't use std::filesystem, see aosp/894015 & b/175635923. - auto dir = std::unique_ptr<DIR, decltype(&closedir)>{opendir(path.c_str()), closedir}; - if (!dir) { - LOG(ERROR) << "Failed to open directory " << path; - return false; - } - dirent *entry; - while ((entry = readdir(&*dir)) != nullptr) { - result->emplace_back(entry->d_name); - } - return true; -} - -bool RealFilesystem::ReadFileStream(const std::string &path, - std::unique_ptr<std::istream> *result) const { - ATRACE_CALL(); - *result = std::make_unique<std::ifstream>(path); - if ((*result)->fail()) { - LOG(ERROR) << "Failed to read file stream: " << path; - return false; - } - return true; -} - -bool RealFilesystem::ResetFileStream(const std::unique_ptr<std::istream> &fileStream) const { - if (fileStream->seekg(0).bad()) { - LOG(ERROR) << "Failed to reset file stream"; - return false; - } - return true; -} - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/RealFilesystem.h b/power-libperfmgr/adaptivecpu/RealFilesystem.h deleted file mode 100644 index 1a877dbd..00000000 --- a/power-libperfmgr/adaptivecpu/RealFilesystem.h +++ /dev/null @@ -1,46 +0,0 @@ -#pragma once - -/* - * 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. - */ - -#include <memory> -#include <ostream> -#include <vector> - -#include "IFilesystem.h" - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -class RealFilesystem : public IFilesystem { - public: - virtual ~RealFilesystem() {} - bool ListDirectory(const std::string &path, std::vector<std::string> *result) const override; - bool ReadFileStream(const std::string &path, - std::unique_ptr<std::istream> *result) const override; - bool ResetFileStream(const std::unique_ptr<std::istream> &fileStream) const override; -}; - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/ThrottleDecision.cpp b/power-libperfmgr/adaptivecpu/ThrottleDecision.cpp deleted file mode 100644 index 31d19e82..00000000 --- a/power-libperfmgr/adaptivecpu/ThrottleDecision.cpp +++ /dev/null @@ -1,48 +0,0 @@ -/* - * Copyright (C) 2022 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. - */ - -#include "ThrottleDecision.h" - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -std::string ThrottleString(ThrottleDecision throttleDecision) { - switch (throttleDecision) { - case ThrottleDecision::NO_THROTTLE: - return "NO_THROTTLE"; - case ThrottleDecision::THROTTLE_60: - return "THROTTLE_60"; - case ThrottleDecision::THROTTLE_70: - return "THROTTLE_70"; - case ThrottleDecision::THROTTLE_80: - return "THROTTLE_80"; - case ThrottleDecision::THROTTLE_90: - return "THROTTLE_90"; - default: - return "unknown"; - } -} - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/ThrottleDecision.h b/power-libperfmgr/adaptivecpu/ThrottleDecision.h deleted file mode 100644 index 8a95c968..00000000 --- a/power-libperfmgr/adaptivecpu/ThrottleDecision.h +++ /dev/null @@ -1,62 +0,0 @@ -/* - * Copyright (C) 2022 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. - */ - -#pragma once - -#include <string> -#include <unordered_map> -#include <vector> - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -enum class ThrottleDecision { - NO_THROTTLE = 0, - THROTTLE_50 = 1, - THROTTLE_60 = 2, - THROTTLE_70 = 3, - THROTTLE_80 = 4, - THROTTLE_90 = 5, - FIRST = NO_THROTTLE, - LAST = THROTTLE_90, -}; - -std::string ThrottleString(ThrottleDecision throttleDecision); - -static const std::unordered_map<ThrottleDecision, std::vector<std::string>> - THROTTLE_DECISION_TO_HINT_NAMES = { - {ThrottleDecision::NO_THROTTLE, {}}, - {ThrottleDecision::THROTTLE_50, - {"LOW_POWER_LITTLE_CLUSTER_50", "LOW_POWER_MID_CLUSTER_50", "LOW_POWER_CPU_50"}}, - {ThrottleDecision::THROTTLE_60, - {"LOW_POWER_LITTLE_CLUSTER_60", "LOW_POWER_MID_CLUSTER_60", "LOW_POWER_CPU_60"}}, - {ThrottleDecision::THROTTLE_70, - {"LOW_POWER_LITTLE_CLUSTER_70", "LOW_POWER_MID_CLUSTER_70", "LOW_POWER_CPU_70"}}, - {ThrottleDecision::THROTTLE_80, - {"LOW_POWER_LITTLE_CLUSTER_80", "LOW_POWER_MID_CLUSTER_80", "LOW_POWER_CPU_80"}}, - {ThrottleDecision::THROTTLE_90, - {"LOW_POWER_LITTLE_CLUSTER_90", "LOW_POWER_MID_CLUSTER_90", "LOW_POWER_CPU_90"}}}; - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/TimeSource.cpp b/power-libperfmgr/adaptivecpu/TimeSource.cpp deleted file mode 100644 index 5191c354..00000000 --- a/power-libperfmgr/adaptivecpu/TimeSource.cpp +++ /dev/null @@ -1,48 +0,0 @@ -/* - * 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 ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL) - -#include "TimeSource.h" - -#include <utils/Trace.h> - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -std::chrono::nanoseconds TimeSource::GetTime() const { - ATRACE_CALL(); - return std::chrono::duration_cast<std::chrono::nanoseconds>( - std::chrono::system_clock::now().time_since_epoch()); -} - -std::chrono::nanoseconds TimeSource::GetKernelTime() const { - ATRACE_CALL(); - timespec ts; - clock_gettime(CLOCK_MONOTONIC, &ts); - return std::chrono::nanoseconds(ts.tv_sec * 1000000000UL + ts.tv_nsec); -} - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/TimeSource.h b/power-libperfmgr/adaptivecpu/TimeSource.h deleted file mode 100644 index d173cfe1..00000000 --- a/power-libperfmgr/adaptivecpu/TimeSource.h +++ /dev/null @@ -1,40 +0,0 @@ -#pragma once - -/* - * 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. - */ - -#include "ITimeSource.h" - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -class TimeSource : public ITimeSource { - public: - ~TimeSource() override {} - std::chrono::nanoseconds GetTime() const override; - std::chrono::nanoseconds GetKernelTime() const override; -}; - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/WorkDurationProcessor.cpp b/power-libperfmgr/adaptivecpu/WorkDurationProcessor.cpp deleted file mode 100644 index 81d026e3..00000000 --- a/power-libperfmgr/adaptivecpu/WorkDurationProcessor.cpp +++ /dev/null @@ -1,120 +0,0 @@ -/* - * 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 "powerhal-adaptivecpu" -#define ATRACE_TAG (ATRACE_TAG_POWER | ATRACE_TAG_HAL) - -#include "WorkDurationProcessor.h" - -#include <android-base/logging.h> -#include <utils/Trace.h> - -using std::chrono_literals::operator""ms; -using std::chrono_literals::operator""ns; - -// The standard target duration, based on 60 FPS. Durations submitted with different targets are -// normalized against this target. For example, a duration that was at 80% of its target will be -// scaled to 0.8 * kNormalTargetDuration. -constexpr std::chrono::nanoseconds kNormalTargetDuration = 16666666ns; - -// All durations shorter than this are ignored. -constexpr std::chrono::nanoseconds kMinDuration = 0ns; - -// All durations longer than this are ignored. -constexpr std::chrono::nanoseconds kMaxDuration = 600 * kNormalTargetDuration; - -// If we haven't processed a lot of batches, stop accepting new ones. In cases where the processing -// thread has crashed, but the reporting thread is still reporting, this prevents consuming large -// amounts of memory. -// TODO(b/213160386): Move to AdaptiveCpuConfig. -constexpr size_t kMaxUnprocessedBatches = 1000; - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -bool WorkDurationProcessor::ReportWorkDurations(const std::vector<WorkDuration> &workDurations, - std::chrono::nanoseconds targetDuration) { - ATRACE_CALL(); - LOG(VERBOSE) << "Received " << workDurations.size() << " work durations with target " - << targetDuration.count() << "ns"; - std::unique_lock<std::mutex> lock(mMutex); - if (mWorkDurationBatches.size() >= kMaxUnprocessedBatches) { - LOG(ERROR) << "Adaptive CPU isn't processing work durations fast enough"; - mWorkDurationBatches.clear(); - return false; - } - mWorkDurationBatches.emplace_back(workDurations, targetDuration); - return true; -} - -WorkDurationFeatures WorkDurationProcessor::GetFeatures() { - ATRACE_CALL(); - - std::vector<WorkDurationBatch> workDurationBatches; - { - ATRACE_NAME("lock"); - std::unique_lock<std::mutex> lock(mMutex); - mWorkDurationBatches.swap(workDurationBatches); - } - - std::chrono::nanoseconds durationsSum = 0ns; - std::chrono::nanoseconds maxDuration = 0ns; - uint32_t numMissedDeadlines = 0; - uint32_t numDurations = 0; - for (const WorkDurationBatch &batch : workDurationBatches) { - for (const WorkDuration workDuration : batch.workDurations) { - std::chrono::nanoseconds duration(workDuration.durationNanos); - if (duration < kMinDuration || duration > kMaxDuration) { - continue; - } - - // Normalise the duration and add it to the total. - // kMaxDuration * kStandardTarget.count() fits comfortably within int64_t. - std::chrono::nanoseconds durationNormalized = - (duration * kNormalTargetDuration.count()) / batch.targetDuration.count(); - durationsSum += durationNormalized; - maxDuration = std::max(maxDuration, durationNormalized); - if (duration > batch.targetDuration) { - ++numMissedDeadlines; - } - ++numDurations; - } - } - - std::chrono::nanoseconds averageDuration = durationsSum / numDurations; - return { - .averageDuration = averageDuration, - .maxDuration = maxDuration, - .numMissedDeadlines = numMissedDeadlines, - .numDurations = numDurations, - }; -} - -bool WorkDurationProcessor::HasWorkDurations() { - std::unique_lock<std::mutex> lock(mMutex); - return !mWorkDurationBatches.empty(); -} - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/WorkDurationProcessor.h b/power-libperfmgr/adaptivecpu/WorkDurationProcessor.h deleted file mode 100644 index eb7f3e29..00000000 --- a/power-libperfmgr/adaptivecpu/WorkDurationProcessor.h +++ /dev/null @@ -1,76 +0,0 @@ -#pragma once - -/* - * 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. - */ - -#include <aidl/android/hardware/power/WorkDuration.h> - -#include <chrono> -#include <vector> - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -using ::aidl::android::hardware::power::WorkDuration; - -struct WorkDurationBatch { - WorkDurationBatch(const std::vector<WorkDuration> &workDurations, - std::chrono::nanoseconds targetDuration) - : workDurations(workDurations), targetDuration(targetDuration) {} - const std::vector<WorkDuration> workDurations; - const std::chrono::nanoseconds targetDuration; -}; - -struct WorkDurationFeatures { - std::chrono::nanoseconds averageDuration; - std::chrono::nanoseconds maxDuration; - uint32_t numMissedDeadlines; - uint32_t numDurations; - - bool operator==(const WorkDurationFeatures &other) const { - return averageDuration == other.averageDuration && maxDuration == other.maxDuration && - numMissedDeadlines == other.numMissedDeadlines && numDurations == other.numDurations; - } -}; - -class WorkDurationProcessor { - public: - bool ReportWorkDurations(const std::vector<WorkDuration> &workDurations, - std::chrono::nanoseconds targetDuration); - - WorkDurationFeatures GetFeatures(); - - // True if ReportWorkDurations has been called since GetFeatures was last called. - bool HasWorkDurations(); - - private: - // The work durations reported since GetFeatures() was last called. - // Ordered from least recent to most recent. - std::vector<WorkDurationBatch> mWorkDurationBatches; - // Guards reading/writing mWorkDurationBatches. - std::mutex mMutex; -}; - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/models/CPPLINT.cfg b/power-libperfmgr/adaptivecpu/models/CPPLINT.cfg deleted file mode 100644 index 3c93947a..00000000 --- a/power-libperfmgr/adaptivecpu/models/CPPLINT.cfg +++ /dev/null @@ -1 +0,0 @@ -exclude_files=.*
\ No newline at end of file diff --git a/power-libperfmgr/adaptivecpu/models/OWNERS b/power-libperfmgr/adaptivecpu/models/OWNERS deleted file mode 100644 index 1f4ba7a0..00000000 --- a/power-libperfmgr/adaptivecpu/models/OWNERS +++ /dev/null @@ -1,4 +0,0 @@ -benm@google.com -miloslav@google.com -mishaw@google.com -silviavinyes@google.com
\ No newline at end of file diff --git a/power-libperfmgr/adaptivecpu/models/model.inc b/power-libperfmgr/adaptivecpu/models/model.inc deleted file mode 100644 index 535d60b2..00000000 --- a/power-libperfmgr/adaptivecpu/models/model.inc +++ /dev/null @@ -1,180030 +0,0 @@ - - - double cpuPolicyAverageFrequencyHz_0_2 = (((double)modelInputs[2].cpuPolicyAverageFrequencyHz[0]*1.0)-1055037.625)/(511727.688); - - double cpuPolicyAverageFrequencyHz_1_2 = (((double)modelInputs[2].cpuPolicyAverageFrequencyHz[1]*1.0)-712505.312)/(336328.062); - - double cpuPolicyAverageFrequencyHz_2_2 = (((double)modelInputs[2].cpuPolicyAverageFrequencyHz[2]*1.0)-730408.0)/(307773.469); - - double cpuCoreIdleTimesPercentage_0_2 = (((double)modelInputs[2].cpuCoreIdleTimesPercentage[0]*100.0)-75.439)/(23.187); - - double cpuCoreIdleTimesPercentage_1_2 = (((double)modelInputs[2].cpuCoreIdleTimesPercentage[1]*100.0)-78.271)/(22.72); - - double cpuCoreIdleTimesPercentage_2_2 = (((double)modelInputs[2].cpuCoreIdleTimesPercentage[2]*100.0)-76.271)/(24.635); - - double cpuCoreIdleTimesPercentage_3_2 = (((double)modelInputs[2].cpuCoreIdleTimesPercentage[3]*100.0)-75.237)/(24.816); - - double cpuCoreIdleTimesPercentage_4_2 = (((double)modelInputs[2].cpuCoreIdleTimesPercentage[4]*100.0)-79.83)/(15.229); - - double cpuCoreIdleTimesPercentage_5_2 = (((double)modelInputs[2].cpuCoreIdleTimesPercentage[5]*100.0)-80.216)/(15.143); - - double cpuCoreIdleTimesPercentage_6_2 = (((double)modelInputs[2].cpuCoreIdleTimesPercentage[6]*100.0)-78.238)/(11.86); - - double cpuCoreIdleTimesPercentage_7_2 = (((double)modelInputs[2].cpuCoreIdleTimesPercentage[7]*100.0)-77.807)/(11.925); - - double averageDuration_2 = (((double)modelInputs[2].workDurationFeatures.averageDuration.count()*1.0)-10657314.0)/(8410847.0); - - double maxDuration_2 = (((double)modelInputs[2].workDurationFeatures.maxDuration.count()*1.0)-14131266.0)/(11521765.0); - - double numDurations_2 = (((double)modelInputs[2].workDurationFeatures.numDurations*1.0)-4.728)/(1.757); - - double numMissedDeadlines_2 = (((double)modelInputs[2].workDurationFeatures.numMissedDeadlines*1.0)-0.255)/(0.492); - - - if (maxDuration_2 <= -0.026791250333189964) { - if (averageDuration_2 <= -0.7279908359050751) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5294590890407562) { - if (numDurations_2 <= 1.008537232875824) { - if (numDurations_2 <= -1.837222695350647) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6656990349292755) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.793600857257843) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6385158896446228) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.4029465913772583) { - if (averageDuration_2 <= -0.8630593419075012) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.999062180519104) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4448178857564926) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7462396025657654) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.807902604341507) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1997819542884827) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9081359207630157) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6782965660095215) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5534783899784088) { - if (maxDuration_2 <= -0.9424203336238861) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.36921538412570953) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9708740413188934) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.18576709181070328) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { - if (averageDuration_2 <= -0.7325868010520935) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.17073660716414452) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.15966938436031342) { - if (averageDuration_2 <= -0.81643345952034) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2880512475967407) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.8521246910095215) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.8048487901687622) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.02268711570650339) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.36878520250320435) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { - if (maxDuration_2 <= -0.982558399438858) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5429504811763763) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.8509195744991302) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307503938674927) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.8801776468753815) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7419779002666473) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5142775774002075) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.20717477053403854) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995391011238) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8374143540859222) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1858297809958458) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7919849455356598) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8659482300281525) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.04485604353249073) { - if (averageDuration_2 <= -0.8259985744953156) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3296032249927521) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.4765240550041199) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7406187653541565) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027660191059) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.7856765985488892) { - if (averageDuration_2 <= -0.7858535647392273) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.28805113583803177) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.249650239944458) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.15979284793138504) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.8545561730861664) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.014108333503827453) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.22261355817317963) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.018933151848614216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2336626723408699) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.8422523438930511) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1892642006278038) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6118060946464539) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514787554741) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7121440172195435) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (averageDuration_2 <= -0.8123093843460083) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.34767337143421173) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.1881876587867737) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.463708221912384) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.702006757259369) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0825804471969604) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.5414674282073975) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - if (maxDuration_2 <= -0.8084281384944916) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.009550269693136215) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.124604046344757) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.134287178516388) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.4410908222198486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3819774985313416) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1252619624137878) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.599594235420227) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.2123268842697144) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.3677852749824524) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2829601541161537) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.7783321738243103) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9610280096530914) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.128638505935669) { - if (numDurations_2 <= -0.12976674735546112) { - if (averageDuration_2 <= -0.7716651260852814) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.29844218492507935) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.25889673084020615) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.7802900969982147) { - if (averageDuration_2 <= -0.7590159475803375) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - if (averageDuration_2 <= -0.7807428240776062) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.599594235420227) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0722964107990265) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.014264244586229324) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5737024396657944) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6693927943706512) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.5566930770874023) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.9587630033493042) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.669339179992676) { - if (maxDuration_2 <= -0.5937521755695343) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6212260723114014) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.35666845738887787) { - if (numDurations_2 <= 0.43938523530960083) { - if (maxDuration_2 <= -0.6625628769397736) { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (averageDuration_2 <= -0.9197312891483307) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5063809156417847) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5355078279972076) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.7482168078422546) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485123872756958) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.665353000164032) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.4765240550041199) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9627330005168915) { - if (maxDuration_2 <= -0.8382506370544434) { - if (averageDuration_2 <= -0.9786600768566132) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.115205705165863) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485749125480652) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13047323748469353) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485448718070984) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.0810239911079407) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -1.0650984644889832) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.290571391582489) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.798003762960434) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3159213364124298) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8714832663536072) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2974159121513367) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.5193292051553726) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7390552461147308) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.8903607726097107) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= -0.6989187151193619) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.1602861285209656) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7244215905666351) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.412794589996338) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -1.082964539527893) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.9083105623722076) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2486878037452698) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (averageDuration_2 <= -0.7504191994667053) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7536594271659851) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.982262134552002) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485732734203339) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.1465429225936532) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (maxDuration_2 <= -0.8526692688465118) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5403872728347778) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485884726047516) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7290031909942627) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.7065938413143158) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4990687072277069) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3595471978187561) { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4661378264427185) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.11780998762696981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2695041596889496) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7483214735984802) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -1.0920391082763672) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - if (maxDuration_2 <= -1.0006976127624512) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (averageDuration_2 <= -1.1075791716575623) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.9811021089553833) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3706755638122559) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484733760356903) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6645813286304474) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.0538491606712341) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.1602861285209656) { - if (averageDuration_2 <= -1.0037696361541748) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - if (maxDuration_2 <= -0.762705534696579) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485300004482269) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1782538890838623) { - if (maxDuration_2 <= -0.7995359301567078) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - if (averageDuration_2 <= -1.017680048942566) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.44464120268821716) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (maxDuration_2 <= -0.6713056862354279) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.8004915118217468) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7006858289241791) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (maxDuration_2 <= -1.093822181224823) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -1.0698245763778687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2591288760304451) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3276389241218567) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8089441657066345) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.07018454559147358) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134997367859) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.9023339152336121) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= -0.6989187151193619) { - if (averageDuration_2 <= -0.7547591924667358) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42605963349342346) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484579682350159) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.7876474559307098) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8116812705993652) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8949894607067108) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (averageDuration_2 <= -1.0324994325637817) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291386604309082) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6712364256381989) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3440431952476501) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.8053693175315857) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - if (maxDuration_2 <= -0.5827248692512512) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0910795331001282) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.0192663073539734) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (maxDuration_2 <= -0.4381233751773834) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2126021981239319) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.16794336587190628) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6002258956432343) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1257103085517883) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2217496633529663) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.28815507888793945) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8256843090057373) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { - if (averageDuration_2 <= -1.0750052332878113) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.372316062450409) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -1.0310088396072388) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9290863573551178) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.593749612569809) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8860599100589752) { - if (maxDuration_2 <= -1.0125353336334229) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9290655255317688) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -1.0245479345321655) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.8211486339569092) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291636347770691) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.332153081893921) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935025334358215) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.4176243543624878) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3881487250328064) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - if (maxDuration_2 <= -0.8473252952098846) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -1.011462688446045) { - if (maxDuration_2 <= -0.9751932919025421) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - if (maxDuration_2 <= -1.0013231039047241) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485115826129913) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3929442167282104) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.7434191703796387) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3224369883537292) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - if (maxDuration_2 <= -1.0356639623641968) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7478798627853394) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7658469378948212) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.1603711247444153) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -1.104837954044342) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -1.022375226020813) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486274838447571) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.067899227142334) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8523993194103241) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.721329003572464) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3179619908332825) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7136523425579071) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0761001892387867) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6694351136684418) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.0439650416374207) { - if (maxDuration_2 <= -0.7408533990383148) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - if (averageDuration_2 <= -1.0600709319114685) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.798312246799469) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.15082854684442282) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.7229069173336029) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1945740580558777) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6508769392967224) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (averageDuration_2 <= -1.09579998254776) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7092162072658539) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8627604842185974) { - if (averageDuration_2 <= -1.1154521703720093) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.324838638305664) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.456205427646637) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7159715294837952) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -1.0431328415870667) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9022583663463593) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -1.1541765332221985) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.8366779685020447) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.291614592075348) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.9083105623722076) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3464956879615784) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.6548356413841248) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.470812126994133) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.319907307624817) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485126256942749) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.943664014339447) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.19243766367435455) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (numDurations_2 <= -0.6989187151193619) { - if (averageDuration_2 <= -0.8178204894065857) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484993934631348) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.25626495480537415) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7521025836467743) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.057180069386959076) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7479124367237091) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.18317823857069016) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4337121397256851) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17696937173604965) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0682660639286041) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.615404963493347) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19949306547641754) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - if (averageDuration_2 <= -0.9237876832485199) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.15325802564620972) { - if (averageDuration_2 <= -0.8484043776988983) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.8759194314479828) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.7439041435718536) { - if (averageDuration_2 <= -0.7913648784160614) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.328986257314682) { - if (maxDuration_2 <= -0.8749291300773621) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - if (averageDuration_2 <= -0.7570918500423431) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= -0.6989187151193619) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9367332756519318) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883544683456) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21903568506240845) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4051479548215866) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1055833101272583) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5596029758453369) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2751573249697685) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - if (maxDuration_2 <= -0.7782309353351593) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.10079115629196167) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.9083105623722076) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2810237780213356) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.522695928812027) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.022702748887240887) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5572963654994965) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6542698442935944) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.498589336872101) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2977132797241211) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.484076499938965) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.37633462250232697) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3589812219142914) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7635813057422638) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.358581781387329) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5270598828792572) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (numDurations_2 <= -0.6989187151193619) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.47222697734832764) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.04836024343967438) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4409313201904297) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.9852244257926941) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.10489858314394951) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7000170946121216) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7541444897651672) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1342943236231804) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3309882879257202) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.7855533957481384) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.325316846370697) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5625047087669373) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7142362892627716) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.07949809357523918) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9174911379814148) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.12433211132884026) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.2214198112487793) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.8484044969081879) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6256552934646606) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.34173186123371124) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6359044015407562) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.8478683531284332) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3074566572904587) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (maxDuration_2 <= -0.8999521434307098) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5392862558364868) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.8850802183151245) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4507238566875458) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23827126622200012) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.191137671470642) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2733210325241089) { - if (numDurations_2 <= 0.43938523530960083) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9289696514606476) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3049383759498596) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.8165296912193298) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7651601135730743) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8721301257610321) { - if (maxDuration_2 <= -1.087277591228485) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5530383288860321) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.05089460499584675) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.8034992218017578) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9861829578876495) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.8056600987911224) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3963569551706314) { - if (maxDuration_2 <= -0.6239646971225739) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { - if (averageDuration_2 <= -0.9451044499874115) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7646843791007996) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1657530665397644) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3167414665222168) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6046102643013) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.753178060054779) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4912053346633911) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744439005851746) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7765167653560638) { - if (averageDuration_2 <= -0.7967119216918945) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= -0.6989187151193619) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7325031757354736) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.062578484416008) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5499763190746307) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4551285654306412) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19082243740558624) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.6055012345314026) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.9889333248138428) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 0.43938523530960083) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.7877056896686554) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111890792847) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.7872776687145233) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -1.1081679463386536) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.196877159178257) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (averageDuration_2 <= -1.1412955522537231) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4030397981405258) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5799986124038696) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485122084617615) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4941857010126114) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5282128751277924) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13804925233125687) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (maxDuration_2 <= -0.9004054963588715) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (maxDuration_2 <= -1.089655876159668) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.20815537124872208) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.8049863278865814) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2332678660750389) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484758198261261) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.4512444734573364) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.1580028533935547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13301532715559006) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.03208610601723194) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17914728075265884) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -1.0686674118041992) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1641283594071865) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (maxDuration_2 <= -0.8461932241916656) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748550534248352) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485066950321198) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -1.1310508251190186) { - if (maxDuration_2 <= -1.1041352152824402) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -1.0320016741752625) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.8897529244422913) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.47318921983242035) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.7157747745513916) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6941463351249695) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.49814507365226746) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23978467285633087) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.20526859164237976) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -1.1395784616470337) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.29826971888542175) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20997002720832825) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6463401019573212) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5713790655136108) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.23155014961957932) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15803858637809753) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.8602667450904846) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06527462415397167) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.39870502054691315) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.040801865980029106) { - if (maxDuration_2 <= -0.9549140334129333) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7479974031448364) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.564881682395935) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.6878324151039124) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.5332252085208893) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1633485108613968) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11260824277997017) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22887099534273148) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2915659546852112) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -1.140200674533844) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3810065984725952) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185136318207) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -1.1380121111869812) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4480827897787094) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - if (maxDuration_2 <= -1.0588330030441284) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (averageDuration_2 <= -1.1142973899841309) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.6132869720458984) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.940060019493103) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -1.1839643120765686) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4167131036520004) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7928220629692078) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432608023285866) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485372722148895) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.25500111281871796) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4433571398258209) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1368951499462128) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.29344412684440613) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5569165647029877) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748504251241684) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.38419879972934723) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4129102826118469) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.14831599220633507) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2595621347427368) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.358581781387329) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.4512444734573364) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9582308232784271) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484140992164612) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.956305742263794) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5128677189350128) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3290051817893982) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.075559675693512) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -1.1089548468589783) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.36147835850715637) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.43823234736919403) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -1.1214942336082458) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.27989813685417175) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.34007662534713745) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.650585949420929) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8793986439704895) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484335899353027) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.585800975561142) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -1.0597599148750305) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.774457573890686) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0761001892387867) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.8165296912193298) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3154873698949814) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.410577729344368) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -1.1272118091583252) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -1.1182195544242859) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3294856548309326) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9290586113929749) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.45513541996479034) { - if (averageDuration_2 <= -1.1407842636108398) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.6482369899749756) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (averageDuration_2 <= -1.153757095336914) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -1.1777567267417908) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -1.0963597893714905) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0018962721806019545) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6160155534744263) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.24204548448324203) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.2170642614364624) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32469581067562103) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (maxDuration_2 <= -1.0964332818984985) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.05494352802634239) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (averageDuration_2 <= -1.1256576776504517) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0985351204872131) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7161533534526825) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12668081000447273) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22425073385238647) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -1.1228739619255066) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - if (averageDuration_2 <= -1.122932255268097) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.06831392273306847) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.06436162441968918) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22102025151252747) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7477732002735138) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6346259713172913) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5499963164329529) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1307147890329361) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.15059547871351242) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.1402334570884705) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.1397899985313416) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.03372570127248764) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (maxDuration_2 <= -1.1058523654937744) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0675973296165466) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7431033551692963) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.750402182340622) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.1558533310890198) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6642155051231384) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485310435295105) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5621910691261292) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9838799834251404) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7207823097705841) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0798861384391785) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.45281267166137695) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.1226099729537964) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7803060412406921) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7469508945941925) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2698152661323547) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.9945657849311829) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6893576681613922) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1882601976394653) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3427407145500183) { - if (maxDuration_2 <= -1.0071660876274109) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -1.0788211226463318) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.1132931113243103) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2492858171463013) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - if (averageDuration_2 <= -1.1099023818969727) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.8568262457847595) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.9514381587505341) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2493610382080078) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -1.0630777478218079) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.293446958065033) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.645003616809845) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - if (averageDuration_2 <= -1.1261913776397705) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (averageDuration_2 <= -1.1293945908546448) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.141859531402588) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3091135025024414) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.8414449393749237) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3189390897750854) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.4452131986618042) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { - if (averageDuration_2 <= -1.116133689880371) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.219297170639038) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485448718070984) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2872317433357239) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7781811356544495) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2823991179466248) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1331097483634949) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4971318393945694) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.358581781387329) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.1516360640525818) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07649283856153488) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -1.0660613179206848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -1.1754996180534363) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8961713314056396) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.6003679037094116) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2446881532669067) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.29564088582992554) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.44187532365322113) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.4203786849975586) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -1.0664233565330505) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.13344067335128784) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9925671517848969) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5491896569728851) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -1.1565128564834595) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484368085861206) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544506549835) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3722195290029049) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5361638367176056) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.29309070110321045) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -1.1422556042671204) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5814048945903778) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4170650690793991) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748243510723114) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -1.1186827421188354) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5978890359401703) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485456764698029) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.8165296912193298) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8992343544960022) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -1.1163416504859924) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3006293773651123) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.2870839834213257) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.754804491996765) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -1.1219031810760498) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4825650155544281) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485326826572418) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -1.137685775756836) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.00989900529384613) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22730571031570435) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48858194053173065) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (averageDuration_2 <= -1.1187191605567932) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0908224768936634) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -1.0905017256736755) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7482313215732574) { - if (maxDuration_2 <= -0.8492147624492645) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7589414715766907) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.8165296912193298) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9046396017074585) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.146455705165863) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9640999138355255) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2574796080589294) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6793947815895081) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485446035861969) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.28983114659786224) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.995596170425415) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.6241148114204407) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2931597232818604) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6645732223987579) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.096486747264862) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.267604112625122) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3365567922592163) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6465607583522797) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5373351275920868) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (averageDuration_2 <= -1.137927234172821) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -1.0650532245635986) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486074268817902) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -1.0629612803459167) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -1.1179692149162292) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2914859652519226) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291255176067352) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -1.0128164887428284) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6490658521652222) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.9083105623722076) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8023571372032166) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6977249085903168) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4611208140850067) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5552370846271515) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (averageDuration_2 <= -1.141780138015747) { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.735918045043945) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.31833410263061523) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592867255211) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5859968364238739) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3685400187969208) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.21740715950727463) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0708580613136292) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.315876007080078) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.087334394454956) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (averageDuration_2 <= -1.1477850675582886) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (maxDuration_2 <= -0.9759683012962341) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1315630078315735) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.45547060668468475) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.1535630226135254) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485639452934265) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2754998803138733) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.1744038462638855) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.9514381587505341) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -1.1110510230064392) { - if (averageDuration_2 <= -1.1195054054260254) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5838580131530762) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (averageDuration_2 <= -1.114879310131073) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (averageDuration_2 <= -1.1537190675735474) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.243281602859497) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484546899795532) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1226530075073242) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.272092878818512) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.183521330356598) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -1.0675175189971924) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2874603867530823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6520103812217712) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484167814254761) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2656489610671997) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - if (maxDuration_2 <= -1.0396681427955627) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3253282308578491) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5140326619148254) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.1322280764579773) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9133457541465759) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5580679178237915) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.109629511833191) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.8211486339569092) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { - if (maxDuration_2 <= -1.007589042186737) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2718964219093323) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7334689199924469) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - if (maxDuration_2 <= -1.0773165822029114) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2553231716156006) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6969980299472809) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3751095533370972) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.62924525141716) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2853108048439026) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.516241043806076) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6896679699420929) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.223183035850525) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { - if (maxDuration_2 <= -1.0638046860694885) { - if (averageDuration_2 <= -1.1372241377830505) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5166559815406799) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3012333512306213) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - if (averageDuration_2 <= -1.1176881790161133) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (averageDuration_2 <= -1.1205242276191711) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3558688759803772) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -1.055702567100525) { - if (averageDuration_2 <= -1.1123510599136353) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7740943133831024) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5441941022872925) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.26742315106093884) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2561483234167099) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -1.128945529460907) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485960423946381) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.9083105623722076) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6610177159309387) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8799616694450378) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.1850348711013794) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8150440752506256) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -1.0613073706626892) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.10163532942533493) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5637430548667908) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - if (maxDuration_2 <= -1.064944326877594) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.8018508851528168) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0102055072784424) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6725481450557709) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0161080360412598) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.46217596530914307) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5910212397575378) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (averageDuration_2 <= -1.182005763053894) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2398325353860855) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9425708949565887) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -1.0565231442451477) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6828773617744446) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9259222149848938) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5396436750888824) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - if (averageDuration_2 <= -1.165008306503296) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7626075446605682) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5948984920978546) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4171066880226135) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -1.0290232300758362) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.16243278235197067) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.20053710788488388) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.746919572353363) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (averageDuration_2 <= -0.8615172803401947) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.1602861285209656) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.103577435016632) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6781022250652313) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.06767288595438004) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -1.0395591855049133) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7161533534526825) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9290246367454529) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.8222339451313019) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484205961227417) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.7367621660232544) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.690058559179306) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999137312173843) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -1.1034157276153564) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7550370395183563) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3259271383285522) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 1.5776891708374023) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8028539419174194) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -1.0166458487510681) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2148973941802979) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.075992226600647) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.9251650869846344) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.011162791401147842) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (averageDuration_2 <= -1.0036506056785583) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.0031773447990417) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (averageDuration_2 <= -0.9910686016082764) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1960631608963013) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.2734594941139221) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.0330615639686584) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.8791232407093048) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - if (averageDuration_2 <= -1.0392404794692993) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3057581782341003) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291138350963593) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.8382760286331177) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.2734594941139221) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3085800409317017) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.353880524635315) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.9623591303825378) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1415292024612427) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - if (maxDuration_2 <= -0.8486828505992889) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486014664173126) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.8208815157413483) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.03977970778942108) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291495382785797) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.25149397552013397) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3835671544075012) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484742105007172) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.279007613658905) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291606843471527) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2395784854888916) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.293201744556427) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -1.1055301427841187) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484611868858337) { - if (maxDuration_2 <= -0.8870227634906769) { - if (maxDuration_2 <= -1.016235589981079) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485959231853485) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.42821288108825684) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9290784001350403) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.7927488684654236) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3408833146095276) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484934329986572) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2578762769699097) { - if (averageDuration_2 <= -0.99959397315979) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.9985058009624481) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5951237082481384) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.4450313597917557) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3735745549201965) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.0582000017166138) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3435497879981995) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3432283401489258) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -1.0291948318481445) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291636347770691) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485564947128296) { - if (maxDuration_2 <= -1.0079740285873413) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291537702083588) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3618700504302979) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.0404698252677917) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.9014565646648407) { - if (averageDuration_2 <= -1.0025625824928284) { - if (averageDuration_2 <= -1.0045748353004456) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7505954504013062) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.9109541475772858) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (averageDuration_2 <= -1.0090680122375488) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3156716227531433) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - if (averageDuration_2 <= -1.0202637910842896) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.9819860458374023) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -1.0333681106567383) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.272525817155838) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3526669144630432) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4779665470123291) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.0836245734244585) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.8955654799938202) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2370771765708923) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { - if (maxDuration_2 <= -1.0439560413360596) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - if (maxDuration_2 <= -0.9798687100410461) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3533889651298523) { - if (averageDuration_2 <= -1.0105772018432617) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291155636310577) { - if (averageDuration_2 <= -1.0635351538658142) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.9443375766277313) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -1.0271289348602295) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.9660933315753937) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (averageDuration_2 <= -1.0499039888381958) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -1.0965925455093384) { - if (maxDuration_2 <= -1.0142803192138672) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485727369785309) { - if (maxDuration_2 <= -1.0478968024253845) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2388505339622498) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2858697175979614) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1326680779457092) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.8211486339569092) { - if (maxDuration_2 <= -0.9291287362575531) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (maxDuration_2 <= -1.0100711584091187) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -1.0765565037727356) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.776446670293808) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2316191792488098) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2946311831474304) { - if (averageDuration_2 <= -1.0315203070640564) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485194206237793) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291480481624603) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.9073147475719452) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3776030540466309) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.9809982776641846) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (maxDuration_2 <= -0.9487824141979218) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291636347770691) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.9437018036842346) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1953186392784119) { - if (averageDuration_2 <= -1.031644582748413) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.8211486339569092) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3407495021820068) { - if (maxDuration_2 <= -0.9094776213169098) { - if (averageDuration_2 <= -1.0095507502555847) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -1.026091456413269) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.9379222691059113) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (maxDuration_2 <= -0.5897175669670105) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.0174895524978638) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -1.0254319906234741) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291250109672546) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2290045022964478) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291621744632721) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3580281734466553) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.9201250672340393) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3264674544334412) { - if (maxDuration_2 <= -0.9943784773349762) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.373979091644287) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485708594322205) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291666150093079) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.238252580165863) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3212879300117493) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484552562236786) { - if (maxDuration_2 <= -0.9854862093925476) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484790980815887) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7142362892627716) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -1.0137358903884888) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.309950828552246) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0803013602271676) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.9083105623722076) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.153515100479126) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.895470380783081) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1548801064491272) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.329683005809784) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.1603711247444153) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - if (maxDuration_2 <= -1.0328804850578308) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (averageDuration_2 <= -1.0020147562026978) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.996011883020401) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - if (averageDuration_2 <= -0.9589091241359711) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291447103023529) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.333849310874939) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.9343993067741394) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.358282208442688) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -1.006304919719696) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -1.0209115743637085) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.8532240092754364) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2533465027809143) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719368040562) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -1.0175373554229736) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3487576246261597) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - if (maxDuration_2 <= -1.0326449871063232) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3946805000305176) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.0142674446105957) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2284963726997375) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.302737057209015) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.258596420288086) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.4097040891647339) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8591063022613525) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3629204630851746) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (averageDuration_2 <= -1.084696352481842) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3495246767997742) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.1083666682243347) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3164162039756775) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485759854316711) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9290714859962463) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (maxDuration_2 <= -1.0301071405410767) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291458129882812) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -1.0741679072380066) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - if (maxDuration_2 <= -1.0176209807395935) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.8211486339569092) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3661340475082397) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { - if (maxDuration_2 <= -0.9992057681083679) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3643078804016113) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7560847997665405) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -1.0932592749595642) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748575747013092) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -1.013224184513092) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (averageDuration_2 <= -1.0937368273735046) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2078545093536377) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2918504476547241) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.9039714932441711) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.275696337223053) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2909134030342102) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -1.0194166898727417) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.278516173362732) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3090343475341797) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.776604950428009) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12511983513832092) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.35822854936122894) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9262494146823883) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5267306864261627) { - if (maxDuration_2 <= -0.9793418943881989) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485418617725372) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6754679083824158) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -1.0883920788764954) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (averageDuration_2 <= -0.8678130507469177) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2927677631378174) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484774589538574) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -1.1069640517234802) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6058647334575653) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5080847293138504) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.6019909977912903) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.27418074011802673) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7072018086910248) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5043977797031403) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21653826534748077) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.5694662630558014) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.002798607514705509) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7482759952545166) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.041945893317461014) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451375007629) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7619648277759552) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -1.0482057332992554) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -1.013658881187439) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22610047459602356) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.9639259874820709) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7089749872684479) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (averageDuration_2 <= -1.0266461372375488) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307503938674927) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7479949593544006) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484270632266998) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (maxDuration_2 <= -0.8138405978679657) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4330156445503235) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { - if (averageDuration_2 <= -1.0733472108840942) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6992211043834686) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -1.0039239525794983) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1754368171095848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.767163097858429) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.7628245055675507) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0760880745947361) { - if (averageDuration_2 <= -0.882167398929596) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4757819175720215) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6059380620718002) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.8073264360427856) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484400868415833) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (maxDuration_2 <= -0.837224930524826) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.011230662930756807) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6162385642528534) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.87022864818573) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (averageDuration_2 <= -0.9237387180328369) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2301260605454445) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.9627688527107239) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.9140808880329132) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485543489456177) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.02178550325334072) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.055817024782299995) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.1783012747764587) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6487291157245636) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541474819183) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7134412527084351) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794910855591297) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.7111433446407318) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (averageDuration_2 <= -0.9448301196098328) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4798939824104309) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.628776878118515) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485156059265137) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8483259081840515) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8231029808521271) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5337179005146027) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.3349531292915344) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7277982532978058) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.039684925228357315) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.4184123277664185) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.0278745293617249) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15021001547574997) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7110344171524048) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (averageDuration_2 <= -0.8757037222385406) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.09887942299246788) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9695247709751129) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.9502376019954681) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.09675727412104607) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142840951681) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0609936211258173) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21617677062749863) { - if (maxDuration_2 <= -0.5133036971092224) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -1.0477152466773987) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6279810667037964) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.9244939684867859) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.9757597744464874) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.910295695066452) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.7688092887401581) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7458375096321106) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748376727104187) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.639811635017395) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.1186873316764832) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.140251100063324) { - if (averageDuration_2 <= -1.033181607723236) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.9658706188201904) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.9655709564685822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.022869829088449478) { - if (averageDuration_2 <= -0.9266463816165924) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (maxDuration_2 <= -0.8848167657852173) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250942707062) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8547589480876923) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0823175422847271) { - if (maxDuration_2 <= -0.7758857011795044) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4441383481025696) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.8806194365024567) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28160543739795685) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.661453515291214) { - if (averageDuration_2 <= -0.9273856282234192) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.226507544517517) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6603581607341766) { - if (averageDuration_2 <= -1.08818519115448) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9110248386859894) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485212981700897) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6401868760585785) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.917200654745102) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.8705223202705383) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.978966236114502) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6941463351249695) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.6241148114204407) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - if (maxDuration_2 <= -1.0592609643936157) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6177415251731873) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8888753354549408) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.663640171289444) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8577660024166107) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.9243354201316833) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.0422221422195435) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400544703006744) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9282716810703278) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9279386699199677) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9788597226142883) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7005505859851837) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.9953777194023132) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.415175676345825) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7161533683538437) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.8211486339569092) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9499585926532745) { - if (maxDuration_2 <= -1.031692624092102) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.0816222429275513) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.352748155593872) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.9953776597976685) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4169272929430008) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.103365421295166) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.3349531292915344) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485814094543457) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485944032669067) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8522885143756866) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.302121102809906) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9463082253932953) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8959862291812897) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748512864112854) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.6982106566429138) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.747825026512146) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9700884819030762) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -1.051196813583374) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.8452296257019043) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.6514046788215637) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7921744287014008) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6337756812572479) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9447527229785919) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.693333387374878) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.0916350483894348) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.7385993301868439) { - if (averageDuration_2 <= -1.0916545391082764) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3946438878774643) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.4416525363922119) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1432478204369545) { - if (maxDuration_2 <= -0.8229405879974365) { - if (numDurations_2 <= 4.4234490394592285) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { - if (numDurations_2 <= 8.976664543151855) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6376909613609314) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (numDurations_2 <= 4.4234490394592285) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5825675427913666) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.4576375484466553) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (numDurations_2 <= 5.561752796173096) { - if (averageDuration_2 <= -0.953942209482193) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.7809206247329712) { - if (averageDuration_2 <= -0.993834376335144) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966037005186081) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.5652061998844147) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0064545571804047) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.19989652931690216) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6412573456764221) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.0507938526570797) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.27841269969940186) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.14831599220633507) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.9565199613571167) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.9281761646270752) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6604832112789154) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9582308232784271) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6822420358657837) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.688767433166504) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.11187028884887695) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.66886043548584) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.688767433166504) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.016184553503990173) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396028995514) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.8759267926216125) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5152014791965485) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.563334882259369) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.26444411277770996) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18215474486351013) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.112024962902069) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.45281267166137695) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.281239315867424) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.355506181716919) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.8788311779499054) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - if (averageDuration_2 <= -0.8788748681545258) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962230682373) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.06313247233629227) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.17581437528133392) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5457973778247833) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485481202602386) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7619648277759552) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3816817998886108) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (averageDuration_2 <= -1.0170779824256897) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (averageDuration_2 <= -0.9041578769683838) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.9968697130680084) { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.6698808670043945) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.808729112148285) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.239214777946472) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5701518654823303) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484130263328552) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.027792247012257576) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5841110944747925) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2079983726143837) { - if (numDurations_2 <= 4.4234490394592285) { - if (averageDuration_2 <= -0.9538386166095734) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6842078566551208) { - if (maxDuration_2 <= -0.9733977913856506) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096855916082859) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (averageDuration_2 <= -0.8656270802021027) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.02118045464158058) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5572963654994965) { - if (maxDuration_2 <= -0.898113340139389) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5807899236679077) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8408733010292053) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0536000095307827) { - if (maxDuration_2 <= -0.7560242712497711) { - if (averageDuration_2 <= -0.8758251070976257) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4758338928222656) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.354511559009552) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484676837921143) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6721392571926117) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5331178903579712) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3998583555221558) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5077452659606934) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.2911977767944336) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4352146238088608) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322239637375) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08883156627416611) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.7423033118247986) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484189569950104) { - if (maxDuration_2 <= -0.779920369386673) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.11246630921959877) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.920729398727417) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.46180689334869385) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.8805562555789948) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.15291116386651993) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089094400406) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.8539432883262634) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.082202672958374) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9231627583503723) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.01659174868836999) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344535857439041) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.8461021780967712) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.8460337817668915) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.266273260116577) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3543331176042557) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.12437156587839127) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - if (maxDuration_2 <= -0.6712373495101929) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8481956124305725) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.891006201505661) { - if (maxDuration_2 <= -0.8950994908809662) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8590781688690186) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.992385745048523) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (averageDuration_2 <= -0.9026017785072327) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768865585327) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.8292393684387207) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.8686310648918152) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9052177369594574) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.7807104587554932) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5946841537952423) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.886878728866577) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.9364836812019348) { - if (maxDuration_2 <= -1.0379889607429504) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2520565390586853) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484628260135651) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8231029808521271) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.8958566188812256) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5129390954971313) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.340703547000885) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.9458115994930267) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9290536344051361) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291123449802399) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.2831013202667236) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -1.1059884428977966) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.333953857421875) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.6241148114204407) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.8072429001331329) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.291614592075348) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.9786150455474854) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.291614592075348) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9032621681690216) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (maxDuration_2 <= -1.0346482992172241) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.8009517192840576) { - if (averageDuration_2 <= -1.0396010875701904) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.7084318399429321) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - if (maxDuration_2 <= -0.9380868971347809) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3208355903625488) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.9781692326068878) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -1.0808135867118835) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291428327560425) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -1.0082728862762451) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -1.0470492839813232) { - if (maxDuration_2 <= -1.0097190141677856) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3530665636062622) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.8211486339569092) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.9394367933273315) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.391759991645813) { - if (maxDuration_2 <= -0.9039310216903687) { - if (averageDuration_2 <= -0.9916525185108185) { - if (maxDuration_2 <= -0.9561145901679993) { - if (maxDuration_2 <= -0.9744209051132202) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.8763347864151001) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486171722412109) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (averageDuration_2 <= -0.9914280474185944) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - if (maxDuration_2 <= -0.9863777756690979) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.516241043806076) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748517245054245) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485286295413971) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485889792442322) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -1.088093876838684) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3786866664886475) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (averageDuration_2 <= -1.0733158588409424) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.9483543634414673) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { - if (maxDuration_2 <= -1.002541422843933) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (averageDuration_2 <= -1.0458515286445618) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.291614592075348) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.8280794322490692) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3287401795387268) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (maxDuration_2 <= -0.996693342924118) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3200352787971497) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291465580463409) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2928558588027954) { - if (averageDuration_2 <= -1.0901435017585754) { - if (maxDuration_2 <= -1.0209894180297852) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485838532447815) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -1.023582935333252) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.8697293996810913) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3870866298675537) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3889294266700745) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.018624484539032) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.9040627181529999) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3347746133804321) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.9126637279987335) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.9230527877807617) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.9986079931259155) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.9123598039150238) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2980167865753174) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - if (averageDuration_2 <= -0.979499101638794) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3433220982551575) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3933184146881104) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9290392696857452) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.9992134273052216) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.9148620963096619) { - if (maxDuration_2 <= -0.9400521814823151) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.9727847576141357) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2249104976654053) { - if (averageDuration_2 <= -1.0350574851036072) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.6241148114204407) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485148012638092) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2908489108085632) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.4031410217285156) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.011927980929613113) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - if (maxDuration_2 <= -0.9574720561504364) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.9325859248638153) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291450679302216) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.19608074426651) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3529844880104065) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.9873325228691101) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3575220704078674) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3909773230552673) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -1.0727104544639587) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (averageDuration_2 <= -1.0448351502418518) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.9581660330295563) { - if (maxDuration_2 <= -0.9952649772167206) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8883399069309235) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.7352620959281921) { - if (averageDuration_2 <= -0.9763303101062775) { - if (averageDuration_2 <= -1.008787453174591) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3895283341407776) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -1.0223047733306885) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.9452011585235596) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (averageDuration_2 <= -1.0656272172927856) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3391226530075073) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -1.0486800074577332) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.9832042157649994) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485884726047516) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (averageDuration_2 <= -1.079748272895813) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -1.0366896390914917) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.371837317943573) { - if (maxDuration_2 <= -0.9468651711940765) { - if (averageDuration_2 <= -1.038196325302124) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.6514046788215637) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - if (averageDuration_2 <= -1.048509955406189) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.9516595900058746) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.9318969249725342) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3103426694869995) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { - if (averageDuration_2 <= -1.0972296595573425) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291368722915649) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5800697803497314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.9877152144908905) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (averageDuration_2 <= -0.9931288659572601) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - if (maxDuration_2 <= -0.9733470380306244) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.37211674451828) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2964827418327332) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.905032753944397) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291350245475769) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3360438346862793) { - if (averageDuration_2 <= -1.0108681917190552) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -1.0495430827140808) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (averageDuration_2 <= -1.0777165293693542) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3851481080055237) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.8972776234149933) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (maxDuration_2 <= -1.0144271850585938) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3684311509132385) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (maxDuration_2 <= -1.031175971031189) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486269176006317) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.367152214050293) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.291614592075348) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485521733760834) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -1.0555903911590576) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (maxDuration_2 <= -0.98959681391716) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486242353916168) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.339514434337616) { - if (maxDuration_2 <= -0.9100348353385925) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -1.0199499726295471) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (averageDuration_2 <= -1.0710989832878113) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -1.0238409638404846) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.2259503602981567) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9290784001350403) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485629916191101) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.41234298050403595) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3965780138969421) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - if (maxDuration_2 <= -0.9619170129299164) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484807074069977) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - if (maxDuration_2 <= -0.9893383979797363) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485348582267761) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.9396292865276337) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -1.0351310968399048) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.9099714756011963) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - if (maxDuration_2 <= -0.9496714174747467) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.8992784917354584) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -1.034917414188385) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.9425823986530304) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9284405410289764) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.291614592075348) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.369373083114624) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3756117224693298) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -1.027065396308899) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.9208594560623169) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.333244502544403) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.9832404553890228) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8547589480876923) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -1.0013737678527832) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.9981065392494202) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4198811501264572) { - if (maxDuration_2 <= -0.8898036181926727) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.8048849701881409) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3577340841293335) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7265906035900116) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3274494409561157) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3157723546028137) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.9514381587505341) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5650087893009186) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.49616678059101105) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6715044975280762) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8017489314079285) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.218447744846344) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 7.553784370422363) { - if (averageDuration_2 <= -0.7597705721855164) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8760176301002502) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9289570152759552) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (averageDuration_2 <= -0.7855864763259888) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7307918667793274) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485164403915405) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3660469800233841) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8712127804756165) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (maxDuration_2 <= -0.782827764749527) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.41890062391757965) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.8222870230674744) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.797648012638092) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.8303461968898773) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.8170760273933411) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7086964845657349) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.7740722596645355) { - if (maxDuration_2 <= -0.8465401232242584) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1701493337750435) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6798609495162964) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3846140503883362) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485294342041016) { - if (averageDuration_2 <= -0.8097341656684875) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.26049620658159256) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8446048498153687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17443285882472992) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.8147572875022888) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3472245931625366) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1967049166560173) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.21005777269601822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7969177663326263) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.872601330280304) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.02006736770272255) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354000866413) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.40047961473464966) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3504288047552109) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7385323941707611) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6804893612861633) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7309025526046753) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485351264476776) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6924245655536652) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21900930255651474) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.06269081309437752) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.27543139457702637) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.6958677172660828) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.46088892221450806) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.01030308729968965) { - if (maxDuration_2 <= -0.4091441333293915) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.372219517827034) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098746106028557) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.4360894709825516) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7682372629642487) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484920918941498) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19680413603782654) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (numDurations_2 <= 6.984632730484009) { - if (averageDuration_2 <= -0.804353803396225) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08209078013896942) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5401929020881653) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (maxDuration_2 <= -0.8085852265357971) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17122217267751694) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.8194015324115753) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.10589347779750824) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1428089737892151) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9475547075271606) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9802378714084625) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.8407254815101624) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5809812843799591) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.8322125673294067) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1201142780482769) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.31137724965810776) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.009050487540662289) { - if (averageDuration_2 <= -0.8191673755645752) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6945921778678894) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7047204077243805) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.058030130341649055) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.8483368158340454) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4710201323032379) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.8106747269630432) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484287023544312) { - if (maxDuration_2 <= -0.6322415769100189) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485196888446808) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.7975149154663086) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6420243680477142) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.7787678837776184) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.7515895664691925) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1731696724891663) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281765937805) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2006777748465538) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.7419438064098358) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.26414854824543) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.558068037033081) { - if (maxDuration_2 <= -0.6657287776470184) { - if (averageDuration_2 <= -0.7823879718780518) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.0620607640594244) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8641326725482941) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.36253778636455536) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484583556652069) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.7852745056152344) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.7303554117679596) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5335986018180847) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.7506937682628632) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.27654576301574707) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7704874575138092) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3755863904953003) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.010587906464934349) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7494457066059113) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5061867833137512) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6422845423221588) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7678030729293823) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.1402511596679688) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0694219321012497) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (maxDuration_2 <= -0.8001918196678162) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2791021913290024) { - if (averageDuration_2 <= -0.7674800753593445) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.49333690106868744) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.409543216228485) { - if (maxDuration_2 <= -0.7555607855319977) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2731478065252304) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5259087085723877) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (averageDuration_2 <= -0.7772516906261444) { - if (maxDuration_2 <= -0.7350080907344818) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.13946834579110146) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5022679567337036) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11960634216666222) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.60592120885849) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.7906136512756348) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3343611806631088) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.11444881185889244) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5819416642189026) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748463898897171) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8481956124305725) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.6822571754455566) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484287023544312) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484880089759827) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.565395325422287) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522207856178284) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.026673121377825737) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (averageDuration_2 <= -0.7672642171382904) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.7560528814792633) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.7294158041477203) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.27841269969940186) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7507732510566711) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2521565333008766) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.768003910779953) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (maxDuration_2 <= -0.7389311790466309) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5059250891208649) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5468851327896118) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08836853131651878) { - if (averageDuration_2 <= -0.7336152493953705) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2521565333008766) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.20819544792175293) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541474819183) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (maxDuration_2 <= -0.7308290600776672) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21014228463172913) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3713100403547287) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539415165781975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (maxDuration_2 <= -0.7945186197757721) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.45281268656253815) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746338248253) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2036862149834633) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.10673816502094269) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9677406549453735) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485158741474152) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.7354689240455627) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.7303845882415771) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.658288836479187) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7358769774436951) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.12442873045802116) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.4443967938423157) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.39341557025909424) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.7586457133293152) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6917275190353394) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7410049736499786) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5110337436199188) { - if (maxDuration_2 <= -0.7470332384109497) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.34579451382160187) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5182701945304871) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07736463472247124) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5469163358211517) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.48569732904434204) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0892229899764061) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.524711012840271) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5585861504077911) { - if (averageDuration_2 <= -0.808156281709671) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.34318535029888153) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.04863450862467289) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404551506042) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - if (maxDuration_2 <= -0.40298226475715637) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.7548709809780121) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.2693729996681213) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3172197490930557) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.16185331344604492) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.23538777232170105) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8600651919841766) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (averageDuration_2 <= -0.728364109992981) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.5193292051553726) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7788002192974091) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.778833419084549) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11963560804724693) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.096980094909668) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.7402895390987396) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.17470641434192657) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9387838244438171) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.7800873517990112) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485416233539581) { - if (maxDuration_2 <= -0.6745981574058533) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486041486263275) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5632779002189636) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.41234298050403595) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3265254646539688) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2853203415870667) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2981659024953842) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.35280799865722656) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { - if (averageDuration_2 <= -0.7487162053585052) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3535720854997635) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (maxDuration_2 <= -0.8081015646457672) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4530888795852661) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (averageDuration_2 <= -0.7396259307861328) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5755446553230286) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.029482188634574413) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5955654680728912) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748376727104187) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748598724603653) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.10518838092684746) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.7500852048397064) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.7715782225131989) { - if (maxDuration_2 <= -0.8088359236717224) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5561891198158264) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.23766880482435226) { - if (maxDuration_2 <= -0.7444449067115784) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.755697101354599) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7793063521385193) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.27160143852233887) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3584589660167694) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.29162636399269104) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.42826317250728607) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.46513141691684723) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.7067153453826904) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4467850476503372) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4677629768848419) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7489094734191895) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (averageDuration_2 <= -0.7506153881549835) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4287114292383194) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.8079240918159485) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.558201402425766) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6725671291351318) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6085982918739319) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3103435039520264) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.7512843906879425) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (averageDuration_2 <= -0.8169448971748352) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5800697803497314) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.31720077246427536) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7150377929210663) { - if (maxDuration_2 <= -0.7112336754798889) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.044247906655073166) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4784690886735916) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748597651720047) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.18149596452713013) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.810246616601944) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.7387859225273132) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.04769654758274555) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.08401471376419067) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.30866384506225586) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.8135310411453247) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5868465304374695) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.3828223645687103) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3789244443178177) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.26611047983169556) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6386152803897858) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6222222447395325) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7087483108043671) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7560848295688629) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.42252254486083984) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3854132294654846) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.7718890905380249) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.351067379117012) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (maxDuration_2 <= -0.7569259107112885) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.11486370116472244) { - if (maxDuration_2 <= -0.668400764465332) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7339423596858978) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6569108963012695) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.4774004966020584) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7017494440078735) { - if (maxDuration_2 <= -0.6605721414089203) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.018045739270746708) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3078194260597229) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4607301950454712) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.740927517414093) { - if (averageDuration_2 <= -0.745466411113739) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.03981145657598972) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.01904148980975151) { - if (averageDuration_2 <= -0.7517834901809692) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.47308366000652313) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485814094543457) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.760990709066391) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.24962031096220016) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.20398568361997604) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.5379520058631897) { - if (maxDuration_2 <= -0.7898178696632385) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (averageDuration_2 <= -0.7686548233032227) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485602796077728) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.10941097140312195) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.7935891151428223) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7479485273361206) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (maxDuration_2 <= -0.4694627970457077) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.7506117820739746) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.27381957322359085) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (averageDuration_2 <= -0.8141740560531616) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.8011089265346527) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.38470418751239777) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4881478250026703) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.8034063279628754) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.8231142461299896) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.7861684858798981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9802378714084625) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.842471718788147) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4264446794986725) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12062125280499458) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (averageDuration_2 <= -0.8499613702297211) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.7734999358654022) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3707921653985977) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5400970131158829) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207121819257736) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.7187942266464233) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7483263611793518) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.8309288024902344) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4299721010029316) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0902730822563171) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748584657907486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.038322687149048) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3635319769382477) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.29130393266677856) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7483864724636078) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - if (maxDuration_2 <= -0.7671505212783813) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.13044001534581184) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3857760578393936) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.777476578950882) { - if (averageDuration_2 <= -0.7794100940227509) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.7867705821990967) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.15585022419691086) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0037497972371056676) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5708175152540207) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.779547929763794) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.16962066292762756) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486128509044647) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.054827746003866196) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - if (averageDuration_2 <= -0.7786392271518707) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581474900245667) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.7958433032035828) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.49911367893219) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.00100468477467075) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484555244445801) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.0055207312107086) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (maxDuration_2 <= -0.7972743511199951) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (averageDuration_2 <= -0.7680263221263885) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3619285821914673) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3231155127286911) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (maxDuration_2 <= -0.7142373621463776) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.7652561068534851) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.16892749071121216) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.7387859225273132) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5800697803497314) { - if (averageDuration_2 <= -0.7570997178554535) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492305755615) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.009141336660832167) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4811306446790695) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2563232034444809) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.184308722615242) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149006992578506) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.6859598159790039) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11568262428045273) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.04693389683961868) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3805430680513382) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19484996795654297) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.07424627617001534) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.7798847258090973) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (averageDuration_2 <= -0.734499990940094) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484937012195587) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3291929066181183) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14679361134767532) { - if (maxDuration_2 <= -0.7612746059894562) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.02966201677918434) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485716640949249) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (maxDuration_2 <= -0.7252799570560455) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.5495784282684326) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.42060625553131104) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.5524210333824158) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.05409933067858219) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (maxDuration_2 <= -0.7308847904205322) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0048209726810455) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7446087896823883) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13670869916677475) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1201142780482769) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177308797836304) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.7357704937458038) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7405288815498352) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9434244632720947) { - if (maxDuration_2 <= -0.7725425362586975) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13366060703992844) { - if (averageDuration_2 <= -0.8268042206764221) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.07318418473005295) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1717766672372818) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5043977499008179) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5384690761566162) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.35187314450740814) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (averageDuration_2 <= -0.8561469614505768) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.8507293462753296) { - if (averageDuration_2 <= -0.8286662995815277) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.29898104071617126) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3605804145336151) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.09690969809889793) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 6.415480613708496) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4894896000623703) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.7577396333217621) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (averageDuration_2 <= -0.7899368703365326) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.38061293959617615) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6471123099327087) { - if (averageDuration_2 <= -0.8116014301776886) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (maxDuration_2 <= -0.8320583999156952) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.27528607845306396) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3543469160795212) { - if (averageDuration_2 <= -0.7883293032646179) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6729749143123627) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0928865596652031) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.7679808139801025) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.27417193353176117) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5168068408966064) { - if (averageDuration_2 <= -0.8207181692123413) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13622209429740906) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.45427730679512024) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7385324090719223) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3128224015235901) { - if (maxDuration_2 <= -0.7821717858314514) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5798149406909943) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4669971764087677) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.7945850193500519) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.04264286905527115) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.872843623161316) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3921894133090973) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5196560025215149) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.19196250289678574) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7712029218673706) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.828738659620285) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (averageDuration_2 <= -0.826255202293396) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.916991949081421) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.9165481328964233) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06678393855690956) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1356804370880127) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.056161461398005486) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.04012217000126839) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.8427512645721436) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.8175154328346252) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (averageDuration_2 <= -0.8166465759277344) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7416684925556183) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6867510378360748) { - if (averageDuration_2 <= -0.8349613845348358) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (averageDuration_2 <= -0.7636381983757019) { - if (maxDuration_2 <= -0.7844056487083435) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2508665844798088) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2062634527683258) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.31173577159643173) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.0760540664196014) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.4869600981473923) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.021470337640494108) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4687176048755646) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7379308640956879) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.8825265765190125) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.2599331811070442) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2124972939491272) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.32310453057289124) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8882669508457184) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.960871696472168) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7066915333271027) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.1186873316764832) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.7496808469295502) { - if (maxDuration_2 <= -0.6135274469852448) { - if (numDurations_2 <= 4.4234490394592285) { - if (averageDuration_2 <= -0.7683515846729279) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1523475646972656) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11992252990603447) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2102959007024765) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.11748655885457993) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3408803939819336) { - if (averageDuration_2 <= -0.7919456958770752) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.014046289026737213) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.29162636399269104) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.31338128447532654) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.8233535289764404) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.1783012747764587) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5605475306510925) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.07926750183105469) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.33435337245464325) { - if (maxDuration_2 <= -0.7450171709060669) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.7636755406856537) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.049295997247099876) { - if (averageDuration_2 <= -0.7592782378196716) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.08977210894227028) { - if (averageDuration_2 <= -0.7571842670440674) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6339916586875916) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5108676254749298) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.16801734268665314) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (maxDuration_2 <= -0.5085676610469818) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.0019657311495393515) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5782906115055084) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2175682634115219) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0152312230784446) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4337121397256851) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9705563485622406) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.00955027062445879) { - if (maxDuration_2 <= -0.39069122076034546) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.04848794639110565) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014949262142181) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.07047391124069691) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.103241678327322) { - if (maxDuration_2 <= -0.7088706791400909) { - if (averageDuration_2 <= -0.7288474142551422) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.595095157623291) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.13486888259649277) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.14102506637573242) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (maxDuration_2 <= -0.7495102286338806) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.4774004966020584) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3919091820716858) { - if (maxDuration_2 <= -0.7259891331195831) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.27443885803222656) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454916000366) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.1678913831710815) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.602836936712265) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5402902066707611) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18841099739074707) { - if (maxDuration_2 <= -0.5508053600788116) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.7503966689109802) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.40274588763713837) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (averageDuration_2 <= -0.7443455457687378) { - if (maxDuration_2 <= -0.7665781378746033) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8331692218780518) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.020937333814799786) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.7479475140571594) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5841111093759537) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.24590055644512177) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2871558964252472) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0008642720349598676) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.27151282131671906) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.24033517390489578) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.054759347811341286) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.552420973777771) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2349560484290123) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.02260992582887411) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.7712205648422241) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7782390713691711) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4055350422859192) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (averageDuration_2 <= -0.7466336786746979) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0022448897361755) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2416770458221436) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.055019253864884377) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.21835857629776) { - if (numDurations_2 <= 4.992600917816162) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.060245608910918236) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.4960829168558121) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.7553328275680542) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.8358139991760254) { - if (averageDuration_2 <= -0.8395074307918549) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.043127499520778656) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.7289285659790039) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.1251209378242493) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.06513987109065056) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7825812995433807) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7161718606948853) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (averageDuration_2 <= -0.7467296123504639) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.8052406013011932) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.31559309363365173) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.06794018670916557) { - if (averageDuration_2 <= -0.7434859871864319) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5275508463382721) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.03485569637268782) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.15153032913804054) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3724527508020401) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2777939885854721) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13173338770866394) { - if (maxDuration_2 <= -0.5172522664070129) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.7789206802845001) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5417258441448212) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.035266198217868805) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.750295102596283) { - if (averageDuration_2 <= -0.8580614924430847) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.43551841378211975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.37451571226119995) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (maxDuration_2 <= -0.7717751562595367) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0196513207629323) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2498842179775238) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26372408866882324) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (numDurations_2 <= 3.8542970418930054) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2653430551290512) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.627381294965744) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2012200579047203) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.03368368651717901) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1819276362657547) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7596466243267059) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.01584817934781313) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9664072096347809) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (averageDuration_2 <= -0.8049529194831848) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.41234298050403595) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.7828226983547211) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.37503907084465027) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1424911804497242) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160940885544) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5083929151296616) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (averageDuration_2 <= -0.7709395289421082) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2386455237865448) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3148536682128906) { - if (averageDuration_2 <= -0.7380797863006592) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.16941408067941666) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.35132333636283875) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3915109634399414) { - if (averageDuration_2 <= -0.7647691071033478) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (averageDuration_2 <= -0.7282002866268158) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.876897096633911) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2405276894569397) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.535465270280838) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.1906251907348633) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.8759267926216125) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.3048789501190186) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.8499226570129395) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - if (maxDuration_2 <= -0.7501257061958313) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9551154375076294) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.010598020628094673) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3624454736709595) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5697498023509979) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.7602118253707886) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.19193264842033386) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9614381194114685) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.851090133190155) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.8414449393749237) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7161533534526825) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.028637409210205) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - if (averageDuration_2 <= -0.8290962874889374) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.810460776090622) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.8099983930587769) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4910624027252197) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.06451795622706413) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.27601249516010284) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3244311064481735) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1298779919743538) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.3343254327774048) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.20367839187383652) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2103499099612236) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.10306189209222794) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.7718333303928375) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.1530070304870605) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - if (maxDuration_2 <= -0.38542306423187256) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3835856020450592) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.0805899500846863) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.030746312346309423) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.7228586971759796) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5396998226642609) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.8282915353775024) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3917168974876404) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5423632860183716) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4876760244369507) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.554700255393982) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2264903336763382) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.06767288595438004) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5415737628936768) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.615404963493347) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.31189730763435364) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.575394093990326) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.6183395385742188) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.1833787560462952) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.06869351863861084) { - if (averageDuration_2 <= -0.7959124147891998) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1110856905579567) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4753562211990356) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.001128285628510639) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6025357842445374) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.06290625967085361) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5768951773643494) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.12629788741469383) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7588281035423279) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.14686497300863266) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9062472879886627) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3425370156764984) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.5270385146141052) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.8542970418930054) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (maxDuration_2 <= -0.7084603905677795) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1243911124765873) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - if (averageDuration_2 <= -0.7551696598529816) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (averageDuration_2 <= -0.7899652123451233) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.24134959280490875) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1374011039733887) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (averageDuration_2 <= -1.088833510875702) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2942990064620972) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.9083105623722076) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -1.049710214138031) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291279911994934) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7478649914264679) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.313846468925476) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.9623591303825378) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.9945657849311829) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748584657907486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -1.0225167274475098) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - if (maxDuration_2 <= -0.8829830884933472) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.0312707424163818) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3544217944145203) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.8211486339569092) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3536303639411926) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.2259503602981567) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.9861167967319489) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3031083941459656) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { - if (averageDuration_2 <= -1.0905925631523132) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3746796250343323) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.2259503602981567) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3128801584243774) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486269176006317) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -1.0084855556488037) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3653416633605957) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (maxDuration_2 <= -0.9719997048377991) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - if (averageDuration_2 <= -1.0828043818473816) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.8617412745952606) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7560848295688629) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7483918368816376) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (maxDuration_2 <= -0.9911088049411774) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -1.0992709398269653) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -1.044123113155365) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (averageDuration_2 <= -1.1002399921417236) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485889792442322) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.33595268428325653) { - if (numDurations_2 <= 5.277176856994629) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21208667755126953) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.17337136715650558) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.283101439476013) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - if (averageDuration_2 <= -0.8274922966957092) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -1.0155973434448242) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (maxDuration_2 <= -0.4745838940143585) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.46035465598106384) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (averageDuration_2 <= -0.8979693949222565) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.8896448910236359) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2658144682645798) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.9623591303825378) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.435492604970932) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.3677852749824524) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5802961885929108) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6466655731201172) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5478420108556747) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22021745890378952) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.8077267110347748) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2469354197382927) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.129861354827881) { - if (maxDuration_2 <= -0.7125962376594543) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3505440950393677) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.8074862062931061) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.9895694851875305) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.8199781775474548) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.863024592399597) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.173066258430481) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.11133947968482971) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.33619174361228943) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7604759037494659) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6577649712562561) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4655948877334595) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.45020928978919983) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.666032075881958) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486244738101959) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19448747485876083) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.7658452391624451) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5396362543106079) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - if (maxDuration_2 <= -0.6349666714668274) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.09281989187002182) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.41723044216632843) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.7657109797000885) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.14635765552520752) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (averageDuration_2 <= -0.7609040439128876) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1647809147834778) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.9748539328575134) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -1.1006761193275452) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.795674204826355) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.8903607726097107) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.009334787726402283) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.05917087383568287) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3399442285299301) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13068731129169464) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.5018714666366577) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -1.0971885919570923) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7824133932590485) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.21663548797369003) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.8184323906898499) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2479664087295532) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.00591033812816022) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.6338953971862793) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.3441046476364136) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -1.0331945419311523) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.0946163535118103) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - if (averageDuration_2 <= -1.028170645236969) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3994808793067932) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.2734594941139221) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2702754139900208) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6544689238071442) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6477978825569153) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.222243070602417) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -1.0320751070976257) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -1.0839268565177917) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (averageDuration_2 <= -1.1043238639831543) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.8809138834476471) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485256195068359) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (averageDuration_2 <= -0.7343926727771759) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.48921041190624237) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2624547705054283) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.2259503602981567) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.35479700565338135) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1833239197731018) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { - if (averageDuration_2 <= -1.0154385566711426) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - if (averageDuration_2 <= -1.022742748260498) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.8723735809326172) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (averageDuration_2 <= -1.0581044554710388) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - if (averageDuration_2 <= -0.9625106155872345) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2909088581800461) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.22980913519859314) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21007779985666275) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2620868980884552) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12123672291636467) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.24567920714616776) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - if (numDurations_2 <= 10.399544715881348) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.34722983837127686) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { - if (maxDuration_2 <= -0.9932868182659149) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.348807454109192) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.291614592075348) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -1.0714022517204285) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (averageDuration_2 <= -1.0794097185134888) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.9417693614959717) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3860049843788147) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (averageDuration_2 <= -1.0624474883079529) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - if (averageDuration_2 <= -0.7457208037376404) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { - if (averageDuration_2 <= -0.9527964293956757) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.8704957962036133) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.272342026233673) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291606843471527) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.2734594941139221) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.1274540424346924) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.366221010684967) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.2259503602981567) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.8165296912193298) { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.9247268736362457) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.9130283892154694) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5140326619148254) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.8903607726097107) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.1602861285209656) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3683481216430664) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748571127653122) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (averageDuration_2 <= -1.0647558569908142) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485619187355042) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.043817937374115) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485749125480652) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6471050083637238) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2802104353904724) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.30548757314682) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - if (averageDuration_2 <= -1.0991342067718506) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -1.0108866095542908) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748216301202774) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -1.0484581589698792) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2947415709495544) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (maxDuration_2 <= -1.0069177746772766) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - if (averageDuration_2 <= -1.019023060798645) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.324276864528656) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291235208511353) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.8211486339569092) { - if (maxDuration_2 <= -0.9674838483333588) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.349295973777771) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (maxDuration_2 <= -1.0364946722984314) { - if (maxDuration_2 <= -1.0883793234825134) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.911265641450882) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.027217447757721) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.929149329662323) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.23255515843629837) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.219234585762024) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9287984669208527) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2355861067771912) { - if (maxDuration_2 <= -0.9938845634460449) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486149966716766) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.8494098782539368) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.1602861285209656) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.361603319644928) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9290801882743835) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9090330302715302) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (maxDuration_2 <= -1.0276352763175964) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.301013469696045) { - if (maxDuration_2 <= -1.017808437347412) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.6514046788215637) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.356334924697876) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7001149952411652) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -1.0795603394508362) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.263729989528656) { - if (averageDuration_2 <= -1.0237813591957092) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (maxDuration_2 <= -1.0047979354858398) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.9130714237689972) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.2259503602981567) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3499057292938232) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3248592019081116) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.9375144839286804) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { - if (maxDuration_2 <= -0.9984181821346283) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3689538836479187) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.9998466074466705) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -1.037847101688385) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3483277559280396) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485980689525604) { - if (maxDuration_2 <= -1.042563021183014) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.4305726289749146) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2693228125572205) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (averageDuration_2 <= -0.9741852581501007) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.9514381587505341) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485354244709015) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.325990617275238) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484465837478638) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (maxDuration_2 <= -0.9180785715579987) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.1602861285209656) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.9523028433322906) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.022074043750763) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (averageDuration_2 <= -1.088738739490509) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3730488419532776) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6433020830154419) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3165090084075928) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.359628677368164) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.075879156589508) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - if (averageDuration_2 <= -1.0833644270896912) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3476848006248474) { - if (maxDuration_2 <= -1.0203790664672852) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (averageDuration_2 <= -1.0903875231742859) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.8165296912193298) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (averageDuration_2 <= -1.0534657835960388) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - if (averageDuration_2 <= -1.0534359216690063) { - if (averageDuration_2 <= -1.0785437226295471) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - if (maxDuration_2 <= -1.0299527049064636) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.0406447052955627) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (averageDuration_2 <= -1.060453176498413) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6922973990440369) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.8471353352069855) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2562904953956604) { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -1.011329710483551) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.9516645967960358) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9206179678440094) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (maxDuration_2 <= -0.9818314909934998) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5948984920978546) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3035842180252075) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8093788325786591) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.8507039248943329) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - if (maxDuration_2 <= -1.067583441734314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.544535219669342) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.8937292993068695) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3571869134902954) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (maxDuration_2 <= -1.0218986868858337) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (maxDuration_2 <= -1.046838104724884) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7438417375087738) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7539418935775757) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.1602861285209656) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8268132209777832) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.4313015341758728) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.8463466763496399) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (averageDuration_2 <= -1.0857316851615906) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485294342041016) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.9848049581050873) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291172027587891) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -1.076952576637268) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7638682126998901) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7210254371166229) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2751178741455078) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { - if (maxDuration_2 <= -1.0485427379608154) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -1.002262830734253) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3124951720237732) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.9532829821109772) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.320068597793579) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485754787921906) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485201060771942) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.9513480365276337) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.9285690188407898) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9086236655712128) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.657477080821991) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - if (maxDuration_2 <= -0.61098712682724) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.818478524684906) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1799364797770977) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.307050883769989) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.2734594941139221) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6865727603435516) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07208741083741188) { - if (averageDuration_2 <= -0.9512304961681366) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8101191520690918) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.36744536459445953) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1866874247789383) { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.29879215359687805) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1535773053765297) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.928666889667511) { - if (averageDuration_2 <= -0.8126868009567261) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.10438440088182688) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5705733001232147) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495784938335419) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7577928304672241) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1063312888145447) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.11780998483300209) { - if (maxDuration_2 <= -0.6981244385242462) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09676655381917953) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.7898687720298767) { - if (numDurations_2 <= 1.5776891708374023) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.21396403014659882) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8481956124305725) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7550370395183563) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5213668942451477) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.5850261449813843) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.797077476978302) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.807980716228485) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.35224373638629913) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.039464294910431) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (averageDuration_2 <= -0.8499094545841217) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.4602272510528564) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 1.5776891708374023) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9626529216766357) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5576138496398926) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7667542695999146) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0650172233581543) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5577892959117889) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.062637560069561) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2898678332567215) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.4576098918914795) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7450697124004364) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.7643721699714661) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5085248649120331) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5263705551624298) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.641837477684021) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.030156010761857033) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (maxDuration_2 <= -0.5654823184013367) { - if (averageDuration_2 <= -0.7754370272159576) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.34365224838256836) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2509037032723427) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1500561237335205) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.7225168645381927) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (maxDuration_2 <= -0.585961639881134) { - if (averageDuration_2 <= -0.7879540622234344) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.6245244145393372) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.2231253385543823) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.8222280740737915) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.846590280532837) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.740801215171814) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2905277609825134) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.468576118350029) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7226000726222992) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.144124150276184) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.8669316470623016) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4096873849630356) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8261885643005371) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6281251758337021) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.043845772743225) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.360865294933319) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.8121003806591034) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3674153089523315) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8182219862937927) { - if (maxDuration_2 <= -0.7783652544021606) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.21237558871507645) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5425611734390259) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.36609192192554474) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.8812378942966461) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.571122646331787) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.32004791498184204) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.7084881961345673) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.36271806061267853) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3534454703330994) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.987255573272705) { - if (maxDuration_2 <= -0.8230975866317749) { - if (maxDuration_2 <= -0.8670803010463715) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.16672417521476746) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8627710342407227) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.45564341545105) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2113341093063354) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.19824778102338314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.070076107978821) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.027829010039567947) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (maxDuration_2 <= -0.4442727714776993) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (maxDuration_2 <= -0.8609030842781067) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.62799733877182) { - if (averageDuration_2 <= -0.8092077374458313) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4876449704170227) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3380926549434662) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4603784382343292) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.7873614430427551) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5305006206035614) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.16156639158725739) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.7400201857089996) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.40182994306087494) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.29162636399269104) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2521565333008766) { - if (maxDuration_2 <= -0.6259147822856903) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (averageDuration_2 <= -0.8150107264518738) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.1274540424346924) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.7736139297485352) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2784769684076309) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.017917000222951174) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.158513307571411) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6546749770641327) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9567003548145294) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0581600833684206) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7815741300582886) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.07104289624840021) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.023027554154396057) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.0423296093940735) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.08961186930537224) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8854923248291016) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0803013602271676) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.7123682498931885) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3777492940425873) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9762924611568451) { - if (averageDuration_2 <= -0.8051114082336426) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.8821186125278473) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.035035729408264) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9791083335876465) { - if (averageDuration_2 <= -0.810306966304779) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.551266223192215) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11914906278252602) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - if (averageDuration_2 <= -0.7589171528816223) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11723202839493752) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.932972013950348) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5159714818000793) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.049554431810975075) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4404693692922592) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.20488007366657257) { - if (averageDuration_2 <= -0.7373886406421661) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.12609514221549034) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.14933308959007263) { - if (averageDuration_2 <= -0.8941020965576172) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5879328548908234) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (numDurations_2 <= 3.8542970418930054) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.525465726852417) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.25455667078495026) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.6781532764434814) { - if (averageDuration_2 <= -0.7552303075790405) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.428275391459465) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.9516345262527466) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7256518006324768) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9957373440265656) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - if (averageDuration_2 <= -0.7857516705989838) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.36395405419170856) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5959151983261108) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (averageDuration_2 <= -0.8202574551105499) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5912904143333435) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4601073861122131) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.8322036564350128) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485992908477783) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - if (maxDuration_2 <= -0.6826016306877136) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.8206155002117157) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0539959073066711) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485056221485138) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.4863998889923096) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.6519053876399994) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.8579664826393127) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.908483386039734) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.6962172985076904) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7747251689434052) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (averageDuration_2 <= -0.967249721288681) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.8431501090526581) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (maxDuration_2 <= -0.7286154329776764) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485083043575287) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.021669305860996246) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.19193264842033386) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.35311898589134216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.608995199203491) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.48212407529354095) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4608675241470337) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0035285949707031) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5875498354434967) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2290563583374023) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7390764355659485) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748570054769516) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6304057240486145) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2968019098043442) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.8194639086723328) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7991330921649933) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6855245232582092) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8410574495792389) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.108070135116577) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3949257582426071) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.556693196296692) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.274079829454422) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= -1.837222695350647) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3140605241060257) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.536464512348175) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.2057141065597534) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2610982060432434) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.2260786294937134) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1057260036468506) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.910374104976654) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.5524985790252686) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { - if (cpuCoreIdleTimesPercentage_5_2 <= -5.066103458404541) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.9108937978744507) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.4812127351760864) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2479664087295532) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6882593631744385) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.5018715858459473) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7587895691394806) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7395582795143127) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.7930396795272827) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8574993014335632) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.462030291557312) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0462589859962463) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.8118938207626343) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089094400406) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3627567887306213) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8073112964630127) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6400941610336304) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.9859343767166138) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.073174238204956) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0618832111358643) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1392356753349304) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372235983610153) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6746163666248322) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0712189078330994) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.7289382815361023) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= -1.837222695350647) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4597925543785095) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6281251907348633) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.1186873316764832) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5595023930072784) { - if (maxDuration_2 <= -0.8622657060623169) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.9516109228134155) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.982878804206848) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3819584399461746) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5582683384418488) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= -1.837222695350647) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5865647494792938) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8674432635307312) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.625324845314026) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9597533643245697) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.863292932510376) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818532556295) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4384190440177917) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7578773498535156) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.3433197736740112) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.61558598279953) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461646318435669) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0396477580070496) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.40805474296212196) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.8717793822288513) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.9615209102630615) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.7217859029769897) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 4.795897483825684) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.6132869720458984) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.976557970046997) { - if (maxDuration_2 <= -0.9458774328231812) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { - if (averageDuration_2 <= -0.8846412301063538) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.6951072216033936) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.760370969772339) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.9395645260810852) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.7139012813568115) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3708256483078003) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.1602156162261963) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.0446120500564575) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.886878728866577) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.2314270734786987) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.9530298113822937) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.952915906906128) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2413274273276329) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.42461895942688) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.844688057899475) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.764528274536133) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.7091822624206543) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.679301142692566) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.471769332885742) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.5471415519714355) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.876897096633911) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.119468092918396) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.43490731716156) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0439395904541016) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2898950576782227) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3550583124160767) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.1703981161117554) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.976557970046997) { - if (averageDuration_2 <= -0.8530292510986328) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.754804491996765) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.5414674282073975) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.319916009902954) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.876897096633911) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.4863998293876648) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736663818359375) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.018952965736389) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.549578309059143) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.7418413162231445) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.67572283744812) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.2170642614364624) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 5.256853342056274) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.173550605773926) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7828230559825897) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.5129289031028748) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.8033015727996826) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.4926325678825378) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.8452296257019043) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592867255211) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.30152371525764465) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.21161343157291412) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.847256302833557) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0225387215614319) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3968586027622223) { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7042964100837708) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.44160401821136475) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.79072505235672) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.8920475542545319) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6531134247779846) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3426513671875) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2776988372206688) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.283101439476013) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.8366457521915436) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.23831994831562042) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4051479548215866) { - if (numDurations_2 <= 0.43938523530960083) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.0904808733612299) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5383095741271973) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.797360420227051) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.41048693656921387) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1051284670829773) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.28452038764953613) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (averageDuration_2 <= -0.7724689841270447) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.3349531292915344) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2171427085995674) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.029591895639896393) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.9088575839996338) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613043069839478) { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.7760578691959381) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.7991592884063721) { - if (averageDuration_2 <= -0.8709433376789093) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7416684925556183) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.3127616047859192) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9246130585670471) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461722493171692) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.7863336503505707) { - if (maxDuration_2 <= -0.8928859829902649) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1735691875219345) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.4638991355895996) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.17866874486207962) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.26936404407024384) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5829523801803589) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.536464512348175) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7231668531894684) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4370013326406479) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.7064703106880188) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.9032242596149445) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.1783012747764587) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17088281363248825) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.2911977767944336) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.8837427794933319) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.151089645922184) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (averageDuration_2 <= -0.8464143574237823) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5615230202674866) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616482853889465) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.4015178084373474) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.31817765533924103) { - if (maxDuration_2 <= -0.8368779122829437) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541325807571) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (averageDuration_2 <= -0.83953657746315) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.8798000514507294) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.9225641787052155) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.7835445404052734) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.2841893434524536) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.04402453824877739) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.45206883549690247) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7483572363853455) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485879063606262) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.8296597898006439) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1186425685882568) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.457105815410614) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - if (maxDuration_2 <= -0.7670060694217682) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.185565710067749) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.128469467163086) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7213721871376038) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089094400406) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.04611337184906) { - if (averageDuration_2 <= -0.7643966376781464) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (averageDuration_2 <= -0.8286256194114685) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0462589859962463) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.9925618171691895) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - if (maxDuration_2 <= -0.8978626132011414) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5470573008060455) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606725335121) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.46509890258312225) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.2265063524246216) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5430884063243866) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.787839263677597) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7847545742988586) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5868000388145447) { - if (averageDuration_2 <= -0.832274466753006) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8141622543334961) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.412516085896641) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461449921131134) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.0867060422897339) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5144524872303009) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.17117134481668472) { - if (averageDuration_2 <= -0.7487320899963379) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.7089187502861023) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.24699638038873672) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6191835701465607) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5765788853168488) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.446592390537262) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5467016398906708) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.7791004180908203) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.394700527191162) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6020592153072357) { - if (maxDuration_2 <= -0.8833401501178741) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.48583483695983887) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.436687707901001) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.7563062310218811) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - if (averageDuration_2 <= -0.8906766474246979) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.16401898860931396) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7533304393291473) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.628063291311264) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7877712547779083) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.7867129743099213) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588659465313) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.029698560945689678) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.617037445306778) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.7944704592227936) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.41568124294281) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.559001550078392) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3190313577651978) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.9112419188022614) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.7767811715602875) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.8112927377223969) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5860671103000641) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3649913668632507) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5959602892398834) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5331270694732666) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.438681423664093) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3028659224510193) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.7853200435638428) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.7533895969390869) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (maxDuration_2 <= -0.7937132716178894) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5159908831119537) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484947443008423) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.459179162979126) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3159213364124298) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - if (maxDuration_2 <= -0.5444355905056) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0247357077896595) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (maxDuration_2 <= -0.7714435458183289) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1967049166560173) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3674155473709106) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5709889829158783) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.8948506116867065) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3069580793380737) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.8538601398468018) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748258113861084) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0722964107990265) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5410775542259216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.8437918424606323) { - if (maxDuration_2 <= -0.4849882423877716) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5326257944107056) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.9019731879234314) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - if (maxDuration_2 <= -0.6401866376399994) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.7182124853134155) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7482954859733582) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.99435293674469) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.174572467803955) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.6982106566429138) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8013654351234436) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.976491093635559) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1853283047676086) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5528357625007629) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4686937481164932) { - if (averageDuration_2 <= -0.8246043622493744) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5390921235084534) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.10593993216753006) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.244322419166565) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6650353968143463) { - if (averageDuration_2 <= -0.8208702504634857) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.1677500009536743) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.255478024482727) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.896321952342987) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7482841312885284) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.976557970046997) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.243561565876007) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3947845697402954) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.7768075168132782) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.9915950894355774) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8188356459140778) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8940888941287994) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.03271237015724182) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6287902295589447) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.411447286605835) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.751625120639801) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.490656018257141) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.3349531292915344) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08648568764328957) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5553211271762848) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8995523154735565) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.080251455307007) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.9649280607700348) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.2170642614364624) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.2911977767944336) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5029692947864532) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.07216671481728554) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5197222828865051) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (maxDuration_2 <= -0.8391194045543671) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (averageDuration_2 <= -0.9175049662590027) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4625393748283386) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.38297484815120697) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6458792686462402) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.2265063524246216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.0614147782325745) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485391795635223) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3156655579805374) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4543817043304443) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.46019111573696136) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7104299664497375) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.6357187926769257) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.7511109113693237) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5185820460319519) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.4184123277664185) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748451441526413) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.8947352766990662) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.375217542052269) { - if (averageDuration_2 <= -0.9879387319087982) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5392486453056335) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7213721871376038) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963484764099) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6369246244430542) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7337320744991302) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8286791443824768) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6141211688518524) { - if (maxDuration_2 <= -0.8520742356777191) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0539959073066711) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4137760996818542) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484254539012909) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8948203325271606) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.7506709396839142) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484205961227417) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.357961893081665) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.591109424829483) { - if (maxDuration_2 <= -0.8939495980739594) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0965060442686081) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (maxDuration_2 <= -0.776683509349823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.41251611709594727) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.6943683922290802) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.01957121305167675) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7483702301979065) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.809019535779953) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4318973124027252) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.3349531292915344) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.2911977767944336) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.696106195449829) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.02121040504425764) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.8502845764160156) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6725745499134064) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6288670301437378) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2898950576782227) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4370974451303482) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.4400789737701416) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4584023356437683) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.45933035016059875) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.033246856182813644) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4694384932518005) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1981717273592949) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.21196596324443817) { - if (maxDuration_2 <= -0.9297112822532654) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.599594235420227) { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.379005551338196) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { - if (maxDuration_2 <= -0.631486713886261) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748290628194809) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (maxDuration_2 <= -0.7409394979476929) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.6672534942626953) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3852276802062988) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.781402587890625) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2829601541161537) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.7147389352321625) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5279523432254791) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.7453612089157104) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.2663294672966003) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.04735138453543186) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6721392869949341) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6106894314289093) { - if (maxDuration_2 <= -0.7561103999614716) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.9713491201400757) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.5675357580184937) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.12993323057889938) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9582308232784271) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.23199841380119324) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.2848228812217712) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.7312058210372925) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.11486532539129257) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (averageDuration_2 <= -0.7355318665504456) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - if (averageDuration_2 <= -0.8994210660457611) { - if (averageDuration_2 <= -0.9288605749607086) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.759820818901062) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.071460247039795) { - if (cpuCoreIdleTimesPercentage_0_2 <= -3.1025575399398804) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.8309287428855896) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5364645272493362) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.634295254945755) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.4512444734573364) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.808729112148285) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.938111960887909) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.538178443908691) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.6183218657970428) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.7104121446609497) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.6184421181678772) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.390951991081238) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5065722763538361) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.9852243959903717) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7968621850013733) { - if (numDurations_2 <= 4.4234490394592285) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9418042302131653) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617576599121094) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2056111916899681) { - if (averageDuration_2 <= -0.7974371314048767) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4241048097610474) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5429091453552246) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5106825232505798) { - if (averageDuration_2 <= -0.8818188607692719) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991478800774) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1937887072563171) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.7900145053863525) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6124650537967682) { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.32995815575122833) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.57896688580513) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.490656018257141) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613218903541565) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.4709976762533188) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4453221559524536) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.319916009902954) { - if (averageDuration_2 <= -0.7746518850326538) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4609447717666626) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.358581781387329) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.5074199438095093) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.565750241279602) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6067830920219421) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (numDurations_2 <= 1.5776891708374023) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.515291452407837) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.688767433166504) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.730912685394287) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4312434196472168) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.2084840536117554) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.01888130372390151) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5636159181594849) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2644413709640503) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5863956212997437) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.70228311419487) { - if (averageDuration_2 <= -0.8299257755279541) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - if (averageDuration_2 <= -0.8337880373001099) { - if (maxDuration_2 <= -0.829325407743454) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4611381888389587) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5009890794754028) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4534569382667542) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.5297839045524597) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.19721277058124542) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { - if (averageDuration_2 <= -0.744540810585022) { - if (averageDuration_2 <= -0.9135403335094452) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6959031820297241) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3533594161272049) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { - if (maxDuration_2 <= -0.7604792714118958) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.37100014090538025) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5846337378025055) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.851523369550705) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5401993095874786) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.49911367893219) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4186374396085739) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4517582058906555) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.419839859008789) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.4010435938835144) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6947869956493378) { - if (averageDuration_2 <= -0.8420543372631073) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.2126322984695435) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.2123268842697144) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8011052906513214) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4195438027381897) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.2925446033477783) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5771068334579468) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3128224015235901) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.35507284104824066) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7996082603931427) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6957186162471771) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.686529815196991) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9793047904968262) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.591629832983017) { - if (numDurations_2 <= 0.43938523530960083) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.201838493347168) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (numDurations_2 <= -0.12976674735546112) { - if (maxDuration_2 <= -0.7955873906612396) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.541467308998108) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.204942524433136) { - if (maxDuration_2 <= -0.8594645261764526) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615896344184875) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.1982994675636292) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9351336658000946) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0795066356658936) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.645317256450653) { - if (maxDuration_2 <= -0.891493171453476) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 1.5776891708374023) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612769484519958) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.27601249516010284) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.688767433166504) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.777643233537674) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.8053269982337952) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.8356015980243683) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.3594858050346375) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3264200687408447) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.009791374206543) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12180164828896523) { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.6557523906230927) { - if (averageDuration_2 <= -0.7716197967529297) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6663342416286469) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4413984566926956) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3441053628921509) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.490656018257141) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3346663564443588) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4285312294960022) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.6321735382080078) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.15136985667049885) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9112135469913483) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.8759267926216125) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.8437918424606323) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5918215215206146) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.03208610601723194) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5406997203826904) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (averageDuration_2 <= -0.8429698050022125) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168212890625) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.9233703315258026) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5557059049606323) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7905055284500122) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.358581781387329) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7344444096088409) { - if (averageDuration_2 <= -0.835861325263977) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9582308232784271) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.8001846969127655) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (averageDuration_2 <= -0.8810626566410065) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.462435781955719) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.46883149445056915) { - if (numDurations_2 <= 1.008537232875824) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.07018454745411873) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.886878728866577) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.370543122291565) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.128291368484497) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6762018799781799) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3001596331596375) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (maxDuration_2 <= -0.8727992177009583) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.876897096633911) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - if (cpuCoreIdleTimesPercentage_0_2 <= -3.1025575399398804) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3103435635566711) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9234714210033417) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.722473919391632) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.92511522769928) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.9243354201316833) { - if (averageDuration_2 <= -0.8013870716094971) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.013622283935547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.6307750940322876) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - if (maxDuration_2 <= -0.7561863660812378) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2887056469917297) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5630521476268768) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.2587443590164185) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.0774096846580505) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.562049627304077) { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5330886244773865) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.814529538154602) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.262742042541504) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.7930396795272827) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.844688057899475) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4609379172325134) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.0446120500564575) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.0976392030715942) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9125365614891052) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.0572593212127686) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.33432537317276) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.2663294672966003) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6684154272079468) { - if (averageDuration_2 <= -0.8119098544120789) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614939093589783) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2335663437843323) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3541070222854614) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6945921778678894) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (averageDuration_2 <= -0.8667159676551819) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.049846856854856014) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 1.5776891708374023) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5630554556846619) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.8768972158432007) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.158935070037842) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.352748155593872) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0902730822563171) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.457859516143799) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7751853466033936) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.6763077080249786) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7079143524169922) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.448354184627533) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.9925618171691895) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.1783012747764587) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6509772539138794) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.450350522994995) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.671301484107971) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.1641088724136353) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.104102611541748) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612173438072205) { - if (averageDuration_2 <= -0.7570270895957947) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 1.5776891708374023) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= -0.12976674735546112) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.23255515843629837) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.916857600212097) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.156500577926636) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 1.5776891708374023) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5661364197731018) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - if (averageDuration_2 <= -0.7553679347038269) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.4858115911483765) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.9265406727790833) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5504419207572937) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.338785767555237) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8022524118423462) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.392748713493347) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.8759267926216125) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.013413906097412) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3638120293617249) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.19144361093640327) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.736188530921936) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.00955027062445879) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.1070023775100708) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3562923669815063) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4007549285888672) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7220813930034637) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3121556639671326) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9142167568206787) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8524277210235596) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5433805584907532) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.48581835627555847) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.760370969772339) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.5074199438095093) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.1272987127304077) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.4203786849975586) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.460392713546753) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.446696937084198) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.7644274830818176) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999137312173843) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.7172511219978333) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4592690467834473) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0436710715293884) { - if (averageDuration_2 <= -0.8955941796302795) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4366065859794617) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.8470445275306702) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.3828223645687103) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9618161916732788) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.83527472615242) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.33432537317276) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - if (averageDuration_2 <= -0.8925842940807343) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { - if (maxDuration_2 <= -0.7636654675006866) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.8779715001583099) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2982683777809143) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.678435742855072) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9612837135791779) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991199404001) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0654678046703339) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6104198098182678) { - if (maxDuration_2 <= -0.63309246301651) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.625324845314026) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4537895917892456) { - if (averageDuration_2 <= -0.8043700456619263) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.0572593212127686) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2029322981834412) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0594176650047302) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.9265407919883728) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.8112369775772095) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3982304334640503) { - if (maxDuration_2 <= -0.866206556558609) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.5304139256477356) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.3102447986602783) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8397803604602814) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.463899254798889) { - if (averageDuration_2 <= -0.8356188237667084) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6226453483104706) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.0371131300926208) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.9446317553520203) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5369972586631775) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5352232456207275) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8984741270542145) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.0211119651794434) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7619648277759552) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.8782627582550049) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.226507544517517) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.462875783443451) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.8691672086715698) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6074519157409668) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.474105715751648) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5143052339553833) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.119892120361328) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.6793462634086609) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - if (maxDuration_2 <= -0.4563359022140503) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.5304139256477356) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.3099656105041504) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6139990389347076) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7546340823173523) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.07018454559147358) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.134287178516388) { - if (maxDuration_2 <= -0.8522311449050903) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.857142448425293) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7372652888298035) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3226464986801147) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1889312863349915) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.0572593212127686) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.226507544517517) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4604092836380005) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.7149617671966553) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4523767232894897) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.8500410318374634) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4324129819869995) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (maxDuration_2 <= -0.5639347732067108) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.302151679992676) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4589674472808838) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619951248168945) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1097821593284607) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.6281538009643555) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5322485864162445) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5236871242523193) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.490656018257141) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4978697299957275) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8814854323863983) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.0620607640594244) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.8396687209606171) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9754036664962769) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { - if (averageDuration_2 <= -0.9301751852035522) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.8544911742210388) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.33754563331604) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -3.2319403886795044) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461440086364746) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7774136662483215) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5331178903579712) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.8246392905712128) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3617719411849976) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (averageDuration_2 <= -0.8643160462379456) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.8228965401649475) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.7120643258094788) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.08371102809906) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.0554805994033813) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.347779631614685) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614352583885193) { - if (maxDuration_2 <= -0.7145614922046661) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.715727150440216) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0902730822563171) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2169177532196045) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.857970118522644) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.8915785253047943) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.7064703106880188) { - if (averageDuration_2 <= -0.8482578098773956) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.20815537124872208) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7822611629962921) { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.8247747719287872) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6227197349071503) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.2966272830963135) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.8019542992115021) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.1580028533935547) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5771068334579468) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.6995680630207062) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.8361814320087433) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7843496799468994) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - if (averageDuration_2 <= -0.8498333096504211) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.853350043296814) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2188429236412048) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.5304139256477356) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.5715272426605225) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.8884061872959137) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.6184421181678772) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.851856768131256) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.546422004699707) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7393279671669006) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7264743447303772) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8978229761123657) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.523591637611389) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.6214135885238647) { - if (cpuCoreIdleTimesPercentage_0_2 <= -3.2319403886795044) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.080590009689331) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.5795979499816895) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7740705013275146) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3197866678237915) { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.8120376765727997) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5748943984508514) { - if (averageDuration_2 <= -0.7539332211017609) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7565419673919678) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6780604124069214) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0722964107990265) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.397077739238739) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1383355855941772) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1919543147087097) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.12016559392213821) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.07682698452845216) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3274243474006653) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.42461895942688) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.5499634146690369) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.8970294892787933) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.027743935585022) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.462475836277008) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0902730822563171) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.9577589929103851) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111890792847) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3659772872924805) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.1756895780563354) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5890317857265472) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.8208415508270264) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.776744842529297) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8919272422790527) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8678250908851624) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.8072891235351562) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.1589351892471313) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7550370395183563) { - if (numDurations_2 <= 1.008537232875824) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.447493553161621) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8357125520706177) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0489644408226013) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8087358474731445) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.185817003250122) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.568963497877121) { - if (maxDuration_2 <= -0.6538098454475403) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.3505582809448242) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.60126531124115) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5815747082233429) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5335706472396851) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.7242187261581421) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.0554805994033813) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.399782419204712) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.7051274180412292) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.7001581788063049) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.599594235420227) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.4852719902992249) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.4965246617794037) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= -0.12976674735546112) { - if (averageDuration_2 <= -0.7830893099308014) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - if (averageDuration_2 <= -0.830251157283783) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9269556701183319) { - if (numDurations_2 <= 2.1468411684036255) { - if (maxDuration_2 <= -0.7728008925914764) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5600056648254395) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0952094793319702) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.9446317553520203) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.805475264787674) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.765721470117569) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.23457122594118118) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5572963654994965) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.3247819542884827) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.8948506116867065) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.7221224308013916) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7555134296417236) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.8437918424606323) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6936625838279724) { - if (averageDuration_2 <= -0.8252517282962799) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5546018779277802) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.4576098918914795) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.6747801303863525) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.6035412549972534) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.21396402455866337) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5602551400661469) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.069406747817993) { - if (maxDuration_2 <= -0.8413304388523102) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7497578859329224) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6291781365871429) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454916000366) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.4106956720352173) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0382118225097656) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7525787353515625) { - if (averageDuration_2 <= -0.9109514653682709) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.7652508318424225) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8907867670059204) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.10788631439209) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.6557488441467285) { - if (averageDuration_2 <= -0.7331299185752869) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9707030951976776) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.0095096826553345) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1119681000709534) { - if (averageDuration_2 <= -0.8989059627056122) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4051479548215866) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.726304829120636) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.7987507879734039) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7157882153987885) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5572963654994965) { - if (maxDuration_2 <= -0.8690582811832428) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5792979001998901) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.802557498216629) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4146862626075745) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1820902824401855) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.797151505947113) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.441839575767517) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.9290050268173218) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.9036868214607239) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.8480863571166992) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3690998554229736) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 4.0006468296051025) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8632377088069916) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9593591094017029) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8338945508003235) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4479955583810806) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.528399646282196) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.7777704000473022) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5800697803497314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.4962093830108643) { - if (averageDuration_2 <= -0.8659754991531372) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.7692475318908691) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0179689228534698) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 5.585340261459351) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.49310925602912903) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.173550605773926) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7543118894100189) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.50235915184021) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7039737701416016) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.094433307647705) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7886603474617004) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.7091822624206543) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.103430151939392) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7192893326282501) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.8911315500736237) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.4073859453201294) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.2786535024642944) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1428000926971436) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { - if (maxDuration_2 <= -0.7683813273906708) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6757878959178925) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0817551612854004) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.8740346431732178) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.504205822944641) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.8454509973526001) { - if (averageDuration_2 <= -0.8810018599033356) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5445061326026917) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6198905408382416) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7542046010494232) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.6304420828819275) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.050779640674591) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1243432760238647) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.7009100914001465) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5913728773593903) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.3349531888961792) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9246130585670471) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6968811452388763) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.842424064874649) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.8415617346763611) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.7768075168132782) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.05594206973910332) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (averageDuration_2 <= -0.7859432697296143) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.47574737668037415) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.8628509640693665) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 6.001366853713989) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.9615209102630615) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.205713987350464) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.8167448043823242) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.8825265765190125) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1273308992385864) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9933372437953949) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4534569382667542) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7111651003360748) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.18798432499170303) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.7361153960227966) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.7316962480545044) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0305752158164978) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2619678378105164) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.7837395370006561) { - if (maxDuration_2 <= -0.860442191362381) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.8088967800140381) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.336305618286133) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.812716007232666) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (maxDuration_2 <= -0.8216032981872559) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.731414794921875) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.5439854860305786) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.865355610847473) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (averageDuration_2 <= -0.77240389585495) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.5347036123275757) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.140251100063324) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.5930910110473633) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7213721871376038) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2693904638290405) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.904642939567566) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.43952974677085876) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1477268561720848) { - if (maxDuration_2 <= -0.6199504435062408) { - if (numDurations_2 <= 0.43938523530960083) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.9623591303825378) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3323505520820618) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3103435039520264) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.8664522767066956) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.218447744846344) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.7946025133132935) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.1783012747764587) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.36783188581466675) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.184145450592041) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617674350738525) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.950202226638794) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.966834545135498) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17070144414901733) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1134390830993652) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.373752474784851) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4610844254493713) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.827701985836029) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.28073687851428986) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.5414674282073975) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.5708313882350922) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.2542518377304077) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.8228538036346436) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.42461895942688) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4609535336494446) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461640477180481) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617537260055542) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1585763804614544) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6946036219596863) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.180942177772522) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.030603766441345) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5661364197731018) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.1070023775100708) { - if (maxDuration_2 <= -0.6471641957759857) { - if (averageDuration_2 <= -0.7583030164241791) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 1.5776891708374023) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7938892543315887) { - if (cpuCoreIdleTimesPercentage_0_2 <= -3.0378661155700684) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.2984808310866356) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.952915906906128) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.632165789604187) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.8452296257019043) { - if (averageDuration_2 <= -0.737939715385437) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.6712814569473267) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.47478847205638885) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.1618149280548096) { - if (averageDuration_2 <= -0.9875132143497467) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.40158165991306305) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6305099427700043) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.403375267982483) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.6404491662979126) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2898950576782227) { - if (maxDuration_2 <= -0.8833832442760468) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.7318853139877319) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.7993290424346924) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.2490766644477844) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.545168399810791) { - if (cpuCoreIdleTimesPercentage_6_2 <= -4.7418212890625) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.8054839074611664) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.162411332130432) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.6660319566726685) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -6.315052270889282) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.5018715858459473) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 6.644861221313477) { - if (maxDuration_2 <= -0.5708287358283997) { - if (cpuCoreIdleTimesPercentage_6_2 <= -4.446711540222168) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612173438072205) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -1.1485382318496704) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.7475018501281738) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1261513233184814) { - if (maxDuration_2 <= -0.7064949870109558) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.9565386176109314) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 5.958153247833252) { - if (maxDuration_2 <= -0.5579375624656677) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.7930396795272827) { - if (numDurations_2 <= 1.5776891708374023) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.000512957572937) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.7984241247177124) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.2663294672966003) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.078379273414612) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.6184421181678772) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 4.092103958129883) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.084824323654175) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.31877863407135) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.832190155982971) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.520781755447388) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.2730184681713581) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.7896812260150909) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.0446120500564575) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.06467604637146) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.7722208797931671) { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3983716368675232) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.507277250289917) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8576572239398956) { - if (maxDuration_2 <= -0.8372654616832733) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.292544722557068) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.3594858050346375) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.4676418900489807) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461249589920044) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.8604344427585602) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1546188592910767) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.2385960817337036) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.8602667450904846) { - if (numDurations_2 <= 1.008537232875824) { - if (averageDuration_2 <= -0.8215171098709106) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.625324845314026) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.8410999178886414) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { - if (averageDuration_2 <= -0.8438116610050201) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5224426984786987) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461689293384552) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.135060667991638) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7213721871376038) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.3127616047859192) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.9243354201316833) { - if (numDurations_2 <= 1.008537232875824) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.1968777179718018) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.261699676513672) { - if (maxDuration_2 <= -0.9035385549068451) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.9437862634658813) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.4987709522247314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.5074199438095093) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.8602667450904846) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.9812395572662354) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.9155310392379761) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.3302619457244873) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.8356302082538605) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.8385125398635864) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.478332042694092) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.8394230008125305) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7741955518722534) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1936134099960327) { - if (maxDuration_2 <= -0.8239206075668335) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3543331176042557) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.8096490502357483) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.46695980429649353) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7550370395183563) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (numDurations_2 <= 0.15480925142765045) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.2385960817337036) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.6347068548202515) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461280882358551) { - if (numDurations_2 <= 1.5776891708374023) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0026546716690063) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2081424482166767) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.2480701804161072) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4093919396400452) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.8428181707859039) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.42461895942688) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.357686996459961) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.0236079692840576) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613032937049866) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4474889039993286) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613492488861084) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9757651090621948) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (maxDuration_2 <= -0.7930420637130737) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.452039897441864) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.37633462250232697) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5435277223587036) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0462590157985687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9791666865348816) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4578933119773865) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { - if (averageDuration_2 <= -0.8867798447608948) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.9343047738075256) { - if (maxDuration_2 <= -0.899321436882019) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.46121346950531) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.7972663044929504) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.10788631439209) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006845474243) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9142167568206787) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.7946025133132935) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744439005851746) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2985063791275024) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.0488998889923096) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615564346313477) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8449939787387848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2308461666107178) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.272525817155838) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.760370969772339) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.442385733127594) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.125472903251648) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (maxDuration_2 <= -0.7844918668270111) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.062656044960022) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.3341875076293945) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.1421070098876953) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.057438313961029) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.6955958604812622) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5661364197731018) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.83610799908638) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.1934889554977417) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.45489123463630676) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3763646483421326) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.2084840536117554) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.13044002512469888) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4601445198059082) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4169272929430008) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.1557555198669434) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.8948088586330414) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.802190363407135) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.996976375579834) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.2016663551330566) { - if (averageDuration_2 <= -0.8924600183963776) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3390844464302063) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -3.2319403886795044) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.986719846725464) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.095744252204895) { - if (maxDuration_2 <= -0.7987862825393677) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (averageDuration_2 <= -0.8311758041381836) { - if (maxDuration_2 <= -0.8168696165084839) { - if (averageDuration_2 <= -0.8701894283294678) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.5493937730789185) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.2846933603286743) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0803013602271676) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.8878712058067322) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (averageDuration_2 <= -0.9031388461589813) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1356128454208374) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.462156355381012) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - if (averageDuration_2 <= -0.8473033607006073) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.4765240550041199) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615212678909302) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.3318238258361816) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.7869105041027069) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.036571502685547) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615153670310974) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9582308232784271) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - if (maxDuration_2 <= -0.880863219499588) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.5495784282684326) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.858051985502243) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (averageDuration_2 <= -0.8532500565052032) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.8408342003822327) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.040866255760193) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1759754419326782) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 4.126484632492065) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.8452967405319214) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.470812126994133) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.988785743713379) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2776988297700882) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.269085645675659) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.2005058526992798) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.0904808733612299) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.741730809211731) { - if (averageDuration_2 <= -0.8489922881126404) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.951748788356781) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.14831599220633507) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616179466247559) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604772090911865) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.119327187538147) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.910463809967041) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746412754059) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.253344774246216) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0948941707611084) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1930317878723145) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9705603718757629) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5664471983909607) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.779565453529358) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.962456464767456) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098746106028557) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4334494471549988) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.6957917511463165) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8960155844688416) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.5499634146690369) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.9332823753356934) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 4.340226411819458) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.1580028533935547) { - if (maxDuration_2 <= -0.7350233197212219) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5907409191131592) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.373752474784851) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4631803035736084) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.5062687397003174) { - if (maxDuration_2 <= -0.7054971158504486) { - if (averageDuration_2 <= -0.8440606594085693) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (numDurations_2 <= 1.008537232875824) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8167273998260498) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.49333690106868744) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.9265406727790833) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.3021210432052612) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0927696228027344) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.7556697726249695) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.9363716542720795) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618534445762634) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.8513839244842529) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9226681292057037) { - if (averageDuration_2 <= -0.8244331181049347) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.7522785365581512) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1932445764541626) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2985881567001343) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.2911977767944336) { - if (numDurations_2 <= 1.5776891708374023) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - if (numDurations_2 <= 1.008537232875824) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461289644241333) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7628713846206665) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9158918261528015) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.290977358818054) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.18975830078125) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461993157863617) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1641283631324768) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.312325596809387) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.442385733127594) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.500523865222931) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4851264357566833) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177308797836304) { - if (maxDuration_2 <= -0.3808312714099884) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1297828555107117) { - if (maxDuration_2 <= -0.6556056439876556) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404849529266) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.8070490062236786) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { - if (maxDuration_2 <= -0.5255822241306305) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4610971808433533) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.609829068183899) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.5783230662345886) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7089749872684479) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615769386291504) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0235978364944458) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.104984164237976) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999027848243713) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.966140866279602) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9596602916717529) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9846479892730713) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.046812891960144) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.1022101640701294) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.41617000102996826) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461523175239563) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.94572114944458) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.8284693658351898) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7991330921649933) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5771068334579468) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.572900652885437) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.5566930770874023) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.094433307647705) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.663603812456131) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.412252426147461) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.203624814748764) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461660921573639) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1051284670829773) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.7301533222198486) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.219858407974243) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.8765342235565186) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9056564569473267) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5228672027587891) { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.114920973777771) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 5.561752796173096) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 5.318671464920044) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1802543997764587) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.9680478572845459) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.6362186670303345) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461458683013916) { - if (averageDuration_2 <= -0.768484503030777) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6658473610877991) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.345606565475464) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.6482369899749756) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.772175431251526) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7509801089763641) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.334991455078125) { - if (numDurations_2 <= 1.008537232875824) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.181956171989441) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5661364197731018) { - if (maxDuration_2 <= -0.704481452703476) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.9623591303825378) { - if (maxDuration_2 <= -0.7030530273914337) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.8602667450904846) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.458408236503601) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 6.189055442810059) { - if (maxDuration_2 <= -0.49114514887332916) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.3302619457244873) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.7944985032081604) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.4876089096069336) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.358807325363159) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= -1.837222695350647) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4166516661643982) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7356986701488495) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3103435635566711) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5456278324127197) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4795267730951309) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.687044084072113) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5627981424331665) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6941463053226471) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748435765504837) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3514363169670105) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.4767167568206787) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.024251937866211) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (averageDuration_2 <= -0.7794765532016754) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.024194462224841118) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9234713912010193) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.2480701208114624) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8547589480876923) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7157882153987885) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.3985434770584106) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614938497543335) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2783265709877014) { - if (maxDuration_2 <= -0.870881974697113) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2460008263587952) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7930554747581482) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295567870140076) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4089773893356323) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.5897117257118225) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.35733550786972046) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.050149083137512) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1339786052703857) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.09959029033780098) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.717830538749695) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.050229251384735) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5457724332809448) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (maxDuration_2 <= -0.7997714877128601) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (averageDuration_2 <= -0.9376527667045593) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.274852991104126) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3923389911651611) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.0867060720920563) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.8236344754695892) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.45685142278671265) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.3262604475021362) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.7221550792455673) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.8613742291927338) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4839763045310974) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5390901863574982) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.9032377600669861) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.652773082256317) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.608930468559265) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12191574275493622) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1641283594071865) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.9914973974227905) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.146611213684082) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.533598005771637) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.8945000469684601) { - if (maxDuration_2 <= -0.7379308640956879) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7018108665943146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7048707604408264) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6922209858894348) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.168618083000183) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5405655801296234) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.4421443939208984) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.5886342525482178) { - if (maxDuration_2 <= -0.695553719997406) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= -0.4143427312374115) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.8960750699043274) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6088766753673553) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.8682698607444763) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1611649990081787) { - if (maxDuration_2 <= -0.5970422625541687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.5037885308265686) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.04885315801948309) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7533897161483765) { - if (maxDuration_2 <= -0.6865323483943939) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.0371131300926208) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.9004814624786377) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - if (maxDuration_2 <= -1.081095278263092) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2268345132470131) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.949642539024353) { - if (maxDuration_2 <= -1.1125970482826233) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.09995615109801292) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -1.0821439623832703) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744439005851746) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0033336126944050193) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { - if (averageDuration_2 <= -0.8384943306446075) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.418287456035614) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4941570311784744) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5577045977115631) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (averageDuration_2 <= -0.8889686763286591) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5929246246814728) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.36093683540821075) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.8058282732963562) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - if (averageDuration_2 <= -0.9070799350738525) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9313026964664459) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5701518654823303) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.36746344715356827) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.47222697734832764) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.4987709522247314) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.8165296912193298) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3195142149925232) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (averageDuration_2 <= -0.7981390058994293) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3367941230535507) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8509162068367004) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485619187355042) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.6012652814388275) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 1.5776892304420471) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8537194430828094) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.291175901889801) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6018891036510468) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484004199504852) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.632410317659378) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28166045248508453) { - if (averageDuration_2 <= -0.786058634519577) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.41234298050403595) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486009001731873) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8065165877342224) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485521733760834) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.30791717767715454) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.842471718788147) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.030746312346309423) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7546007633209229) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.27897073328495026) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485465109348297) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (numDurations_2 <= 8.976664543151855) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3864848017692566) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.36378298699855804) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.722473919391632) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5978890359401703) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8325167596340179) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6743242144584656) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.7768998742103577) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -1.1047683954238892) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.944080650806427) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41109657287597656) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6793991923332214) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8012139797210693) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (averageDuration_2 <= -0.8523324728012085) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - if (averageDuration_2 <= -0.8060285151004791) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (maxDuration_2 <= -0.537627637386322) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.7506955564022064) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.1678913235664368) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2271507978439331) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.6321735382080078) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.2443223595619202) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000302791595) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (averageDuration_2 <= -0.777691513299942) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8889637887477875) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.8777441382408142) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.9753090739250183) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8439154028892517) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6305421590805054) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -1.028695523738861) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7551562786102295) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27559196949005127) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7601846754550934) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - if (maxDuration_2 <= -0.35378724336624146) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.934496134519577) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2398325316607952) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.8205778300762177) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.03208610415458679) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.06391064077615738) { - if (averageDuration_2 <= -0.8721393942832947) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7211587131023407) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.2896693348884583) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (maxDuration_2 <= -0.7254219651222229) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8932941854000092) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1233071088790894) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.2005058526992798) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.03168726712465286) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744439005851746) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0028385603800415993) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7550351321697235) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9677406847476959) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -1.117720603942871) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8085508942604065) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7006680071353912) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (averageDuration_2 <= -0.8070890009403229) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1535773053765297) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470267772675) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091150283813477) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (maxDuration_2 <= -0.6245066821575165) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4477521777153015) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.2005058526992798) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616394639015198) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7951833009719849) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2776988409459591) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.8778327703475952) { - if (numDurations_2 <= 1.862265169620514) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.2259503602981567) { - if (maxDuration_2 <= -1.0358437895774841) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.8239940702915192) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638475418091) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.7970774918794632) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4486286044120789) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4605225920677185) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8375648558139801) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7063737511634827) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8249529004096985) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (maxDuration_2 <= -0.6585916876792908) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.7418249845504761) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuCoreIdleTimesPercentage_0_2 <= -3.2319403886795044) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.7555809319019318) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12538408860564232) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.9968165755271912) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.9984461069107056) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.04191499203443527) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616208672523499) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.7631543278694153) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -1.1196978688240051) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.511135220527649) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.484076499938965) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.06636212021112442) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.8568262457847595) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.5848501920700073) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.47639887034893036) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - if (averageDuration_2 <= -0.830085426568985) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.05177287291735411) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.815709799528122) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5680118203163147) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.8356302231550217) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.8237700760364532) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -1.0118963420391083) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.8168685138225555) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6618636250495911) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4437549114227295) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186675310135) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (maxDuration_2 <= -0.6737751662731171) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.7888006269931793) { - if (maxDuration_2 <= -0.7395339608192444) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614401459693909) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.507671058177948) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.807615339756012) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486074268817902) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488866329193) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614381790161133) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6337586343288422) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.293517827987671) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.610805869102478) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4539019465446472) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3692631125450134) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.6362186670303345) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6941463053226471) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.3828223645687103) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0605764985084534) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.9678915143013) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4124236106872559) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.2443223595619202) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.3796340823173523) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.7895140647888184) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3163074254989624) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485351264476776) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.47222697734832764) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.16126471012830734) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7661713361740112) { - if (averageDuration_2 <= -0.8084303438663483) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1680329218506813) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.6698316931724548) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (averageDuration_2 <= -0.8142719864845276) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.6955958604812622) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (averageDuration_2 <= -0.9147166609764099) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5595702826976776) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (averageDuration_2 <= -0.7695389091968536) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0603214967995882) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5080965459346771) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2754700630903244) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4482031911611557) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.10645005106925964) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5910808444023132) { - if (maxDuration_2 <= -0.6310662925243378) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6299374103546143) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.9731746912002563) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4205306768417358) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0650932528078556) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4319772124290466) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1707926988601685) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.13728278875350952) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.02273319847881794) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.4987709522247314) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.994560718536377) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1754608750343323) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.7539052069187164) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.22462796419858932) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - if (maxDuration_2 <= -0.7752878963947296) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7867300510406494) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.8997635543346405) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (averageDuration_2 <= -0.7776250243186951) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.53995680809021) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6991482973098755) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - if (maxDuration_2 <= -0.7863051891326904) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5641268491744995) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.8063688576221466) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.903601735830307) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.020337074995041) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.27841269969940186) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.9915950894355774) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.9713491201400757) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.6038247644901276) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.1783012747764587) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619140028953552) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.9169616103172302) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.007768270559608936) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0299912141636014) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.06710292771458626) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.8542775809764862) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22984347492456436) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08151936950162053) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.40749405324459076) { - if (averageDuration_2 <= -0.7826807796955109) { - if (maxDuration_2 <= -0.41466568410396576) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (maxDuration_2 <= -0.5084206759929657) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5416039228439331) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21511530131101608) { - if (maxDuration_2 <= -0.8260734379291534) { - if (averageDuration_2 <= -0.8654394745826721) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4479955583810806) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3128224015235901) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (averageDuration_2 <= -0.8078104555606842) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.619788646697998) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4575278759002686) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.03518171887844801) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.6184421181678772) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748597651720047) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1718374267220497) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4621045589447021) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.7925673127174377) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6759060919284821) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.31755438446998596) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.9395075738430023) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.8396335542201996) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616394639015198) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28946828842163086) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794910855591297) { - if (maxDuration_2 <= -0.6634492576122284) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4602226614952087) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614762663841248) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2950655072927475) { - if (averageDuration_2 <= -0.7372916340827942) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617488980293274) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.7744091749191284) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22714968025684357) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7484507262706757) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484799027442932) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484554946422577) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.1218186616897583) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.029591891914606094) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.24142257124185562) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3981632590293884) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.382701113820076) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.551739454269409) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3938084840774536) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.5717911720275879) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.330262005329132) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6552769839763641) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.4340621829032898) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5906673669815063) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.580150842666626) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.9746512174606323) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5707750022411346) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5333273410797119) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7394886910915375) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.7453612089157104) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.649523138999939) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.130955457687378) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.21237558871507645) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5400970131158829) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091154009103775) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.8455296456813812) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.372219517827034) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (maxDuration_2 <= -0.8251465857028961) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.2831013202667236) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (maxDuration_2 <= -0.7232942879199982) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (averageDuration_2 <= -0.7565992474555969) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7089749872684479) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617342352867126) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.38558030128479) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuCoreIdleTimesPercentage_4_2 <= -5.012147903442383) { - if (averageDuration_2 <= -0.7373141646385193) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.1516360640525818) { - if (maxDuration_2 <= -0.6060763299465179) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.14856670051813126) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (maxDuration_2 <= -0.5708591938018799) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.4340621829032898) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7570379674434662) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.5744280219078064) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.0867060422897339) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.7564848065376282) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6645484864711761) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.5566930770874023) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2839902378618717) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.23538777232170105) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.7724799811840057) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6197241842746735) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281765937805) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.1934889554977417) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8442182540893555) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.1475108861923218) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.5499634146690369) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.7160786986351013) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.1904139518737793) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615055918693542) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5648982524871826) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9343138933181763) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.450029730796814) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.985480934381485) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.01303433463908732) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.779975950717926) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.0055207312107086) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.8405724167823792) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17575901001691818) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3253724277019501) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6063745617866516) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057653248310089) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3205846548080444) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.24937009811401367) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.49690526723861694) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5596505403518677) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1697663068771362) { - if (maxDuration_2 <= -0.8268257677555084) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7237499356269836) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.9649280905723572) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (averageDuration_2 <= -0.9301206469535828) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.211623668670654) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.41470272839069366) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.8803159296512604) { - if (averageDuration_2 <= -0.8867250084877014) { - if (averageDuration_2 <= -0.8980647921562195) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.5418986082077026) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.4670807123184204) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4110719561576843) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.7327817380428314) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3831367492675781) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8619505763053894) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9833564758300781) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 6.125706672668457) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4514347910881042) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.278653383255005) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.001600444316864) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.1397976875305176) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1472140550613403) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.1025971174240112) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.9812395572662354) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5389954149723053) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.802154541015625) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3819584399461746) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0493888854980469) { - if (maxDuration_2 <= -0.4872220903635025) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4294117093086243) { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.528386116027832) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6426037847995758) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2793676853179932) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.04518895223736763) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617577195167542) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6843219995498657) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6897867321968079) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4624680280685425) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.7947405874729156) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9846312403678894) { - if (maxDuration_2 <= -0.8527984619140625) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.6347068548202515) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5336875915527344) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.33969302475452423) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.9710743725299835) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5387052446603775) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8252379894256592) { - if (maxDuration_2 <= -0.5665536522865295) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7619648277759552) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.8577800691127777) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7867361903190613) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.353586882352829) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3253334313631058) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999027848243713) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.7414031326770782) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5220772624015808) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.445237159729004) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461571991443634) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4507567286491394) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.8508365154266357) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.8228964507579803) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613961577415466) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8356260657310486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3606687188148499) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2975804805755615) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.10966694355011) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7469146847724915) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.32002659142017365) { - if (averageDuration_2 <= -0.83043372631073) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.7551783919334412) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.3707275390625) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.905255436897278) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.966581106185913) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.830192446708679) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.8336945176124573) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - if (maxDuration_2 <= -0.6223993897438049) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8229105472564697) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4624377489089966) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.1078864336013794) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.8634464740753174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514787554741) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6661685705184937) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4906747490167618) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.8385125398635864) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2865267992019653) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.7411022186279297) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7496738731861115) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.394932746887207) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.8827180564403534) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8706024289131165) { - if (averageDuration_2 <= -0.9420485198497772) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.593091070652008) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3730994313955307) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0538286566734314) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5956095159053802) { - if (numDurations_2 <= 5.277176856994629) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (maxDuration_2 <= -0.8873393833637238) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (maxDuration_2 <= -0.8422902822494507) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.006060117069864646) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1424911804497242) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3949337750673294) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6858274042606354) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6824533343315125) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606539070606) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.5566930770874023) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.1885876655578613) { - if (maxDuration_2 <= -0.5662876963615417) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 13.529880046844482) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3579035997390747) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.1557555198669434) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4892008304595947) { - if (maxDuration_2 <= -0.9147280156612396) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.0530831813812256) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.2951493263244629) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7123874425888062) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.472243070602417) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8780922591686249) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.45958754420280457) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.722435861825943) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2557140588760376) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5946207046508789) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7728005051612854) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.9367633759975433) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (maxDuration_2 <= -0.893126517534256) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.7746219038963318) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.9004712700843811) { - if (averageDuration_2 <= -0.9028914868831635) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 6.415480613708496) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.916979730129242) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4398447275161743) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.8584083318710327) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.8117936849594116) { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.9524775743484497) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (averageDuration_2 <= -0.9899145066738129) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.2951493263244629) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.2896693348884583) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089094400406) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.7897141575813293) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4252666234970093) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4604972004890442) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9219915270805359) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7550370395183563) { - if (numDurations_2 <= -0.9834946841001511) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0659967064857483) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.012343046255409718) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.15088313072919846) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8273943066596985) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5277437567710876) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.430165648460388) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (averageDuration_2 <= -0.950395792722702) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6227197349071503) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -1.016234278678894) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.2110331878066063) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.8056853115558624) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.9506865739822388) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.6246561259031296) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.5147928297519684) { - if (numDurations_2 <= 1.008537232875824) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9652901887893677) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.913651466369629) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.23538777232170105) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.33236296474933624) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2559059858322144) { - if (averageDuration_2 <= -0.9241907000541687) { - if (averageDuration_2 <= -0.9859334528446198) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.8165296912193298) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - if (averageDuration_2 <= -1.0553088784217834) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.8515954911708832) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2347669005393982) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3299046456813812) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.0757222175598145) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.013138234615326) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - if (maxDuration_2 <= -0.4580049514770508) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.9378644824028015) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.565378785133362) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.6371042132377625) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1215521693229675) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2026745080947876) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.1562942266464233) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8788168132305145) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.1186873018741608) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4479955583810806) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4027637541294098) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.828829526901245) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0930700302124023) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.839429259300232) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.9521813690662384) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 6.130904674530029) { - if (maxDuration_2 <= -0.7244238257408142) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.2677568793296814) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.3491384983062744) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3543576002120972) { - if (averageDuration_2 <= -0.9546661078929901) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188198328018) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6990544199943542) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.530005156993866) { - if (averageDuration_2 <= -0.9123550057411194) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.418988823890686) { - if (averageDuration_2 <= -1.0079702138900757) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.955012559890747) { - if (maxDuration_2 <= -0.5524489879608154) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7109135687351227) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400544703006744) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8283106088638306) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2398509979248047) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.8228965401649475) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3267014026641846) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6532392501831055) { - if (numDurations_2 <= 4.4234490394592285) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.9237745702266693) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0757389068603516) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.89655339717865) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4581053256988525) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.450324833393097) { - if (averageDuration_2 <= -1.0267493724822998) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7243913412094116) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.45020928978919983) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.25132977217435837) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5602551400661469) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4913182854652405) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.9169768691062927) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2284765243530273) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7040690779685974) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8225417733192444) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.97329181432724) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9806111454963684) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615085124969482) { - if (maxDuration_2 <= -0.4947442561388016) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2741315364837646) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5986303687095642) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7327274680137634) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4551565051078796) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.9754125475883484) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3980958461761475) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.8206180334091187) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1535773053765297) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6357339024543762) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (maxDuration_2 <= -0.815540075302124) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.3514859676361084) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (averageDuration_2 <= -0.9065405130386353) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1840259432792664) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.903745949268341) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.6302811205387115) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.8499744832515717) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.49466609954834) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.15320611000061) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.9070146679878235) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.509147524833679) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9246130585670471) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.9997538626194) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.886861801147461) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4606340527534485) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9521702229976654) { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7850407958030701) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06687165051698685) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1571465134620667) { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.8432158529758453) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.35311898589134216) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5440351963043213) { - if (maxDuration_2 <= -0.7570678293704987) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.4485859274864197) { - if (averageDuration_2 <= -0.8464416265487671) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.723693072795868) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7691256105899811) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5466059148311615) { - if (averageDuration_2 <= -0.7833032310009003) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.9265406727790833) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5035655498504639) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0462589859962463) { - if (averageDuration_2 <= -0.8279664516448975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.538621187210083) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5016209036111832) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5332921743392944) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.3666815757751465) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8741868734359741) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.7355797290802002) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7707876861095428) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6552789211273193) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9386163949966431) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.487790107727051) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.8244539499282837) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7733666896820068) { - if (averageDuration_2 <= -0.7749311625957489) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.60456782579422) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.608403742313385) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8349080085754395) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1782058477401733) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6227197349071503) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6740623712539673) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.6041640937328339) { - if (averageDuration_2 <= -0.7945300936698914) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7981260418891907) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6522490084171295) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (maxDuration_2 <= -0.81557297706604) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6447227001190186) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4597684144973755) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8340048491954803) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.05159341171383858) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.7727617621421814) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7723895609378815) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8788294792175293) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7658993005752563) { - if (maxDuration_2 <= -0.5049230456352234) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4051479548215866) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7077453434467316) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8612527251243591) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.061204195022583) { - if (maxDuration_2 <= -0.5938813984394073) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6383099555969238) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9582308232784271) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6345333456993103) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.632796049118042) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (numDurations_2 <= 9.545816898345947) { - if (maxDuration_2 <= -0.8716923594474792) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7087380290031433) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.8026283979415894) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8646871745586395) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.493836522102356) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.320164144039154) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2675538063049316) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 4.992600917816162) { - if (maxDuration_2 <= -0.8139824271202087) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0197227597236633) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.113975167274475) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5728220343589783) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (maxDuration_2 <= -0.6589663028717041) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.054711103439331) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.951200842857361) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.10016503557562828) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.9293405413627625) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.3950346112251282) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4472568035125732) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (maxDuration_2 <= -0.7945745289325714) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2612701654434204) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.931052565574646) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.8036738634109497) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.1618149280548096) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4377331733703613) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7089749872684479) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.7592433094978333) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3983694911003113) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5586511194705963) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - if (cpuCoreIdleTimesPercentage_5_2 <= -5.06610369682312) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -5.110644102096558) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.805087387561798) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9410525262355804) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.1176055669784546) { - if (cpuCoreIdleTimesPercentage_3_2 <= -3.011645793914795) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7770498692989349) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7160633206367493) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5224948823451996) { - if (maxDuration_2 <= -0.6990969479084015) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.0371131300926208) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4302920997142792) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4597282409667969) { - if (numDurations_2 <= 2.4314171075820923) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.3099656701087952) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3256698250770569) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - if (maxDuration_2 <= -0.36321648955345154) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.23538777232170105) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4115738123655319) { - if (averageDuration_2 <= -0.8722012341022491) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0242519676685333) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.7829872071743011) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.800653338432312) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5957834422588348) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0462589859962463) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4540817141532898) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7575851082801819) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.042469322681427) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8718798756599426) { - if (maxDuration_2 <= -0.6845466196537018) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1571571826934814) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9715858399868011) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.18896040320396423) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20519939064979553) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5486844778060913) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2478381991386414) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.7706505656242371) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.8568443357944489) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.968813419342041) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6436975598335266) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.773976743221283) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6957504749298096) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (maxDuration_2 <= -0.7119098007678986) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6461068987846375) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619667530059814) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7011626660823822) { - if (numDurations_2 <= 0.43938523530960083) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461756706237793) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.8048639893531799) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (maxDuration_2 <= -0.688140481710434) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (averageDuration_2 <= -0.8446581363677979) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6684078276157379) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05320047400891781) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7287174463272095) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4778245687484741) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0355538129806519) { - if (maxDuration_2 <= -0.5815573632717133) { - if (averageDuration_2 <= -0.7998105883598328) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.0901434333063662) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6085982918739319) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.2542518377304077) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5246248841285706) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.36999616026878357) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.8542970418930054) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6384816765785217) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (maxDuration_2 <= -0.754046231508255) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (maxDuration_2 <= -0.7571184039115906) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.14831599220633507) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.756370484828949) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3127827644348145) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.8134504854679108) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5593773126602173) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2623846307396889) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.464223861694336) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0682660341262817) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.660483181476593) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.32598327100276947) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.38049089908599854) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5559250116348267) { - if (numDurations_2 <= 0.43938523530960083) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.011927980929613113) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5431971251964569) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -5.132140636444092) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.7666589915752411) { - if (averageDuration_2 <= -0.8746799230575562) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.479934275150299) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (numDurations_2 <= 6.984632968902588) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.2328837439417839) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379605531692505) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - if (maxDuration_2 <= -0.6834424138069153) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3280709385871887) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.07682698965072632) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4637714624404907) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4629448056221008) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400545448064804) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.8667867481708527) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8198107779026031) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9228427112102509) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.4765240550041199) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7305030822753906) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.29162636399269104) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.933671712875366) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.8825189769268036) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.444722294807434) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.458875298500061) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0682660341262817) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7778335213661194) { - if (averageDuration_2 <= -0.8371435105800629) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.33878976106643677) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3556060940027237) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.48610520362854004) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.757363885641098) { - if (maxDuration_2 <= -0.7965651154518127) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3543331176042557) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4627230763435364) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.7627346515655518) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5679146647453308) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.10755031183362007) { - if (maxDuration_2 <= -0.38182656466960907) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6295213997364044) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3013823628425598) { - if (averageDuration_2 <= -0.7429067492485046) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.9630446434020996) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6015337705612183) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.8719946444034576) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.093846917152405) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 4.4234490394592285) { - if (maxDuration_2 <= -0.65662881731987) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9708781242370605) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9306021332740784) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6256362199783325) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14081879705190659) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8647972941398621) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5280683040618896) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.540590688586235) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -3.059429883956909) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9558411240577698) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6544794738292694) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.775170773267746) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6076676845550537) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.14397023618221283) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.8559397161006927) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.0406334400177) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6336471438407898) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (numDurations_2 <= -0.9834946841001511) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.3683982938528061) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8599216341972351) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618817567825317) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.8213829696178436) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.43551841378211975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.9437862038612366) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9670726954936981) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5489716231822968) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0583035349845886) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.7689407467842102) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (maxDuration_2 <= -0.6173821985721588) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1842116117477417) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.6446698904037476) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0076655745506287) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.7969815731048584) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.354353427886963) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.721750855445862) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1419968008995056) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.31924521923065186) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.906386137008667) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.583980083465576) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.8492881953716278) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.203004002571106) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 4.563915252685547) { - if (averageDuration_2 <= -0.8613669872283936) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8993547558784485) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.2663294672966003) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.099716305732727) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - if (maxDuration_2 <= -0.6612307131290436) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3617601990699768) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.4203787446022034) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.9199471473693848) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0915238857269287) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.2108792066574097) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.281714677810669) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619022607803345) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.232560396194458) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (averageDuration_2 <= -0.8123577237129211) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.405747413635254) { - if (maxDuration_2 <= -0.8575548827648163) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.9363716542720795) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.498576521873474) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.8414876759052277) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0551009774208069) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9874106347560883) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.01875431463122368) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2101417779922485) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9421150982379913) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539397239685) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9582308232784271) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9589083194732666) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.4446340799331665) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.803770899772644) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.7972663044929504) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.4643927812576294) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7603563070297241) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.239214777946472) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7712722718715668) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3983716368675232) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (maxDuration_2 <= -0.6897666156291962) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9058563113212585) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.1475949883460999) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3260526657104492) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.0093899965286255) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7619648277759552) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (maxDuration_2 <= -0.8228392601013184) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3960390090942383) { - if (averageDuration_2 <= -0.5157813429832458) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.007528921356424689) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8359135687351227) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - if (averageDuration_2 <= -0.5456342995166779) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22983158379793167) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6392495036125183) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486260831356049) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485783398151398) { - if (maxDuration_2 <= -0.5975258648395538) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5927896797657013) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7853769659996033) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6358963251113892) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.604397177696228) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.6920459866523743) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0470258593559265) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7771201431751251) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.7789206802845001) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.023341845721006393) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5546751320362091) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - if (maxDuration_2 <= -0.530951589345932) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.546684741973877) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9480875134468079) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9544385373592377) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2961706221103668) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.638963371515274) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5272070169448853) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.46955904364585876) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5369200110435486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0035837888717651) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0394643247127533) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6336411833763123) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.6483595371246338) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6048111915588379) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.743807464838028) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0210902094841003) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.6912557780742645) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5500552952289581) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606725335121) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - if (averageDuration_2 <= -0.5877749621868134) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5824218392372131) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7400625646114349) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.32002659142017365) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9081359207630157) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8532929420471191) { - if (maxDuration_2 <= -0.6454192101955414) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5994768440723419) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.31720077246427536) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9038569331169128) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7482589483261108) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7694981396198273) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8636158108711243) { - if (maxDuration_2 <= -0.628004252910614) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8737764954566956) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6504161655902863) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.49333688616752625) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.38419879972934723) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.6712436676025391) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.884510725736618) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484709620475769) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.730811208486557) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485968470573425) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7819785177707672) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040612459183) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8385233581066132) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (maxDuration_2 <= -0.6964022219181061) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4698442667722702) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.31374046206474304) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.952339768409729) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7374774813652039) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7550464570522308) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6633287072181702) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8814240992069244) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7698891162872314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.61076620221138) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6701431572437286) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485992610454559) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.320826455950737) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.3715362697839737) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6787854433059692) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8597661256790161) { - if (averageDuration_2 <= -0.6796804666519165) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6905139684677124) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (numDurations_2 <= -1.837222695350647) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6075789928436279) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6899658143520355) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8599216341972351) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.554974764585495) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8261885643005371) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40743666887283325) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6277902126312256) { - if (averageDuration_2 <= -0.6431439220905304) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17794623225927353) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.3609192669391632) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5069827735424042) { - if (numDurations_2 <= 1.008537232875824) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.31902356445789337) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.060293251648545265) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0682660341262817) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485435009002686) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4465062767267227) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6861523687839508) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.6041235029697418) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748603343963623) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6483242511749268) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.5124680399894714) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12704207003116608) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { - if (maxDuration_2 <= -0.4175705313682556) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.591272622346878) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - if (averageDuration_2 <= -0.5772822797298431) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7619648277759552) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.2223153710365295) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5332270860671997) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (maxDuration_2 <= -0.4324399530887604) { - if (averageDuration_2 <= -0.6844503879547119) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485789954662323) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.6816843748092651) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (maxDuration_2 <= -0.7213441133499146) { - if (averageDuration_2 <= -0.7046564817428589) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4334983825683594) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.46484625339508057) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.16997188329696655) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6630618572235107) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.7191852927207947) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485575973987579) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20825889706611633) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { - if (maxDuration_2 <= -0.6980890333652496) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536155462265) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - if (averageDuration_2 <= -0.6949074864387512) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4904349148273468) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.7220077514648438) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { - if (maxDuration_2 <= -0.6588171124458313) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7550370395183563) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4685062915086746) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7699243724346161) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486139237880707) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.35733549669384956) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5296683013439178) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.6504805684089661) { - if (averageDuration_2 <= -0.6531988382339478) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8023247122764587) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486269176006317) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6691294610500336) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4222228527069092) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748591959476471) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485432326793671) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6177831590175629) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4125160872936249) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107351958751678) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.6706370711326599) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4100015163421631) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.842471718788147) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - if (maxDuration_2 <= -0.711248904466629) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7185181379318237) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485837042331696) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748336672782898) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - if (averageDuration_2 <= -0.6261669099330902) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (maxDuration_2 <= -0.7037317156791687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7192880809307098) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7047324776649475) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (maxDuration_2 <= -0.6842199563980103) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2714546322822571) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.6771233975887299) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22378838062286377) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4285396933555603) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (averageDuration_2 <= -0.6054178774356842) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.6675294637680054) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4195016771554947) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936677023768425) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3724527508020401) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.6110678315162659) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2513269782066345) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (averageDuration_2 <= -0.6188427209854126) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - if (maxDuration_2 <= -0.6951915919780731) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (averageDuration_2 <= -0.6744060218334198) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6136997044086456) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.6604484617710114) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6394027173519135) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (averageDuration_2 <= -0.6120813190937042) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748609870672226) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748603343963623) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8814854323863983) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5798149406909943) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7178165912628174) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.532955139875412) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485911548137665) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.6033738553524017) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6572758555412292) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.8165296912193298) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3376786708831787) { - if (averageDuration_2 <= -0.5650409460067749) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.361456036567688) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.48195189237594604) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.19196250289678574) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23954086005687714) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.2084840536117554) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6508654356002808) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { - if (maxDuration_2 <= -0.5290368497371674) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21867432445287704) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (averageDuration_2 <= -0.6498101055622101) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748496949672699) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485716640949249) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.3376462757587433) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5041942000389099) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (averageDuration_2 <= -0.5611105561256409) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5205740034580231) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8000273108482361) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486188113689423) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5214121639728546) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (maxDuration_2 <= -0.6176987886428833) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (averageDuration_2 <= -0.6011090874671936) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.4266907870769501) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (averageDuration_2 <= -0.6032699346542358) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4068826586008072) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.4921558350324631) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.41336560249328613) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484335899353027) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (maxDuration_2 <= -0.5634079277515411) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484835386276245) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6128653585910797) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6249295771121979) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7576852440834045) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6146012842655182) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5974780023097992) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5316459834575653) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485824823379517) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23322559893131256) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4946656823158264) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { - if (averageDuration_2 <= -0.6335780322551727) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22531962394714355) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485611140727997) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485007643699646) { - if (maxDuration_2 <= -0.4611505717039108) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.40549637377262115) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5104211270809174) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6547143757343292) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.532973974943161) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (maxDuration_2 <= -0.6466854214668274) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5264957845211029) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2731478065252304) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.2848228812217712) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7538074254989624) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5115297734737396) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8547589480876923) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3073139637708664) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - if (averageDuration_2 <= -0.5249474942684174) { - if (maxDuration_2 <= -0.5617717802524567) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5655190050601959) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485272586345673) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485611140727997) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.4673936665058136) { - if (maxDuration_2 <= -0.6263783574104309) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5324617028236389) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486114799976349) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7481594085693359) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5590387880802155) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (maxDuration_2 <= -0.6375018954277039) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4305918663740158) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6507574915885925) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2645939588546753) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48034144937992096) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5602551400661469) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746412754059) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6957877278327942) { - if (averageDuration_2 <= -0.660845160484314) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488866329193) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.5284946858882904) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4532432556152344) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5421792566776276) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.6566312313079834) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354000866413) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2642674148082733) { - if (maxDuration_2 <= -0.5991974771022797) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5389397144317627) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1849617063999176) { - if (maxDuration_2 <= -0.572259783744812) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.5639564692974091) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5945397615432739) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.13044001534581184) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.405854269862175) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5394801497459412) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.6324848234653473) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592867255211) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6987986862659454) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - if (averageDuration_2 <= -0.6675359606742859) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7475108206272125) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.18870143964886665) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.5995874404907227) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6970761120319366) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.5134455561637878) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.04597241245210171) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.790956050157547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485424280166626) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7650184333324432) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7952302098274231) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.04997594468295574) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7010264098644257) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.7021442651748657) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.4015178084373474) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1397358924150467) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (averageDuration_2 <= -0.6868498623371124) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485724985599518) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1201142780482769) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485521733760834) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5936229825019836) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6456277966499329) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5782218277454376) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.6147219240665436) { - if (maxDuration_2 <= -0.6379780471324921) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05733483098447323) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.643456220626831) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6731904745101929) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.08903738111257553) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - if (averageDuration_2 <= -0.6119145154953003) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6230626702308655) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5701518654823303) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8424716889858246) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.016184553503990173) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.14633847400546074) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - if (averageDuration_2 <= -0.6104327440261841) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.007084414828568697) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096855878829956) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.27841269969940186) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.536476343870163) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6444239318370819) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1161888241767883) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6172641515731812) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5662826299667358) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.3652705103158951) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.27553869783878326) { - if (numDurations_2 <= 3.2851450443267822) { - if (numDurations_2 <= 2.7159931659698486) { - if (averageDuration_2 <= -0.5692499876022339) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5977484285831451) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7318758368492126) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160940885544) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 0.439385250210762) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6304270625114441) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5489367246627808) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541474819183) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.694299191236496) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.10667318850755692) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.08962436020374298) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (maxDuration_2 <= -0.20087847113609314) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5218600034713745) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5698562264442444) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7082695364952087) { - if (averageDuration_2 <= -0.6612632572650909) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - if (averageDuration_2 <= -0.6955849230289459) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6525955498218536) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.21691525727510452) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.04798941686749458) { - if (maxDuration_2 <= -0.6930412948131561) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517697870731354) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - if (averageDuration_2 <= -0.6839952170848846) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - if (averageDuration_2 <= -0.6835059821605682) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.18038693815469742) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6536406576633453) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2356841340661049) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (averageDuration_2 <= -0.7137193977832794) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6812206208705902) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485706210136414) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - if (averageDuration_2 <= -0.7054987847805023) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.35733549669384956) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2445385828614235) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2498842179775238) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6139989942312241) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (maxDuration_2 <= -0.4572376310825348) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.11027532815933228) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748517245054245) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.34279532730579376) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (maxDuration_2 <= -0.38142649829387665) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0253522926941514) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.842471718788147) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6834248900413513) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484937012195587) { - if (averageDuration_2 <= -0.631439208984375) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.5090310871601105) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6039360761642456) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6352212727069855) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (averageDuration_2 <= -0.6671374440193176) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6866046786308289) { - if (averageDuration_2 <= -0.6149443089962006) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6944897174835205) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5411479473114014) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6286375820636749) { - if (maxDuration_2 <= -0.6716552376747131) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.4215746968984604) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.0423296093940735) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.026302258484065533) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.46510113775730133) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5988070070743561) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.042329579591751) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.668794721364975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8599216341972351) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.663274109363556) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6424522995948792) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.64404296875) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.7656015157699585) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5453222990036011) { - if (averageDuration_2 <= -0.5461871922016144) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (maxDuration_2 <= -0.585097998380661) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.027122885920107365) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486009001731873) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (maxDuration_2 <= -0.6191018521785736) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6282239556312561) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07829613238573074) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6878625154495239) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.40787293016910553) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.22422988712787628) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5374608933925629) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.588569164276123) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06822561100125313) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5781760513782501) { - if (maxDuration_2 <= -0.4789426326751709) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.300174742937088) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485353648662567) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - if (averageDuration_2 <= -0.5880172848701477) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.002244919538498) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6295723915100098) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485992610454559) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6042692065238953) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.6921901702880859) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4419638216495514) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8675388097763062) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5713100731372833) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6139990389347076) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.6195882260799408) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1996062621474266) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - if (maxDuration_2 <= -0.22818096727132797) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6852182149887085) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.663274109363556) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6514990925788879) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2029322981834412) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - if (numDurations_2 <= -0.6989187151193619) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5804727673530579) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899798870087) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404849529266) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3159213215112686) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7619152665138245) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (averageDuration_2 <= -0.5452398657798767) { - if (maxDuration_2 <= -0.6641103625297546) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.34787847101688385) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6154486835002899) { - if (averageDuration_2 <= -0.5607624053955078) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4662224352359772) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6752177774906158) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319651782512665) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492305755615) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.4416525363922119) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.11068692803382874) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6383446455001831) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9217394888401031) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6941938102245331) { - if (numDurations_2 <= -1.837222695350647) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9093784391880035) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.42492644488811493) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23459776490926743) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6046440899372101) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.43739528954029083) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.20044124871492386) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.05957953445613384) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2924148291349411) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.45932169258594513) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0871067643165588) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7840979397296906) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.47124210000038147) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5237013697624207) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.5342198610305786) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - if (maxDuration_2 <= -0.6540328860282898) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8714148998260498) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.21237558871507645) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.34762173891067505) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5263397395610809) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7476334869861603) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9901047646999359) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8368437886238098) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486025393009186) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5359322726726532) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6760017573833466) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5618625581264496) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7643071413040161) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6155336499214172) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6422670781612396) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.5969028472900391) { - if (averageDuration_2 <= -0.6759653985500336) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.47244781255722046) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5369020104408264) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.41351819038391113) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.45444560050964355) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484953105449677) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.770579993724823) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.3828223645687103) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9387838244438171) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6042501926422119) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5863262712955475) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5210910439491272) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (averageDuration_2 <= -0.7150693535804749) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.519459456205368) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.39651884138584137) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7481858432292938) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { - if (averageDuration_2 <= -0.6015669405460358) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3505530059337616) { - if (maxDuration_2 <= -0.5795058608055115) { - if (maxDuration_2 <= -0.7217139005661011) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40935175120830536) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6024494171142578) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5781534910202026) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4069344401359558) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5657877922058105) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.610083132982254) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.41048693656921387) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (numDurations_2 <= 2.7159931659698486) { - if (averageDuration_2 <= -0.638565331697464) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14634910970926285) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.626937210559845) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.28022557497024536) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13262738287448883) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5639826357364655) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6744546592235565) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1899980828166008) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.552857905626297) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414793252945) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404551506042) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2463686391711235) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4980434477329254) { - if (averageDuration_2 <= -0.627543568611145) { - if (averageDuration_2 <= -0.7154621779918671) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5412898659706116) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7993462979793549) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485218644142151) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (maxDuration_2 <= -0.689498096704483) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.5480370819568634) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.4083185940980911) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4732617288827896) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6083711385726929) { - if (maxDuration_2 <= -0.6663544178009033) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40701262652873993) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.08822394162416458) { - if (maxDuration_2 <= -0.4295426160097122) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.08839131146669388) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403679728507996) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5407092273235321) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5203063786029816) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.31380872428417206) { - if (averageDuration_2 <= -0.5786982774734497) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2984289079904556) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781625390052795) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.12949947267770767) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (numDurations_2 <= 1.0085371732711792) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2446230947971344) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2851778566837311) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (maxDuration_2 <= -0.6765104532241821) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5222593545913696) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6917480528354645) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7582287192344666) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5823552459478378) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999027848243713) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.0802515149116516) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5017153173685074) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.0423296093940735) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5403911769390106) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5186237692832947) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.535802811384201) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4796397536993027) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.757517397403717) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.11604801192879677) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.49329011142253876) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.005905506433919072) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.14113952219486237) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (maxDuration_2 <= -0.5534570813179016) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7893184721469879) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.7789206802845001) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.0545014007948339) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6546649634838104) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8972694575786591) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.6686395704746246) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7807700037956238) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8067096173763275) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (averageDuration_2 <= -0.517570823431015) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (maxDuration_2 <= -0.7105295062065125) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (averageDuration_2 <= -0.6506192982196808) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7193965315818787) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7479998171329498) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.020146310795098543) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.16618554294109344) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.14633847028017044) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6064302027225494) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5101828575134277) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.667258620262146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8032214045524597) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.047010223381221294) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6012665331363678) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1896573901176453) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.523535817861557) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5769451558589935) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3540363758802414) { - if (maxDuration_2 <= -0.6117343008518219) { - if (averageDuration_2 <= -0.6909461617469788) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (averageDuration_2 <= -0.6851257085800171) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6393543183803558) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0009598145261406898) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485310733318329) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7961551249027252) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (maxDuration_2 <= -0.5917007327079773) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (maxDuration_2 <= -0.5429995954036713) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5616816878318787) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5549914836883545) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486139237880707) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485779225826263) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9738000631332397) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (maxDuration_2 <= -0.6409969329833984) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5662066042423248) { - if (averageDuration_2 <= -0.5878584980964661) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.526660829782486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.56511589884758) { - if (maxDuration_2 <= -0.6013149619102478) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2638162672519684) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5930226743221283) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.606551855802536) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.5235054194927216) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.607789933681488) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.33874310553073883) { - if (maxDuration_2 <= -0.5596063733100891) { - if (averageDuration_2 <= -0.598783940076828) { - if (maxDuration_2 <= -0.6287640333175659) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5687431395053864) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (averageDuration_2 <= -0.6792748272418976) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.6913191676139832) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.6528525054454803) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6040748357772827) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.14397023618221283) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5514818131923676) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5849686861038208) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7389303743839264) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9167837500572205) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (averageDuration_2 <= -0.5778533816337585) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (averageDuration_2 <= -0.5858899354934692) { - if (maxDuration_2 <= -0.5800730586051941) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6351085603237152) { - if (averageDuration_2 <= -0.5561364591121674) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6997388601303101) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.6096473336219788) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5562358200550079) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.5649585723876953) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.4618343561887741) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8643427491188049) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7363891005516052) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.47486500442028046) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.842471718788147) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485738694667816) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5422701239585876) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5866097211837769) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5356996059417725) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6189756095409393) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.20948798209428787) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.17552682384848595) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3543331176042557) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2627904862165451) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.46973055601119995) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3995477110147476) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4549883306026459) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4470599740743637) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.081233449280262) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5141535997390747) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40597008168697357) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.5840265452861786) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5293951034545898) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748531848192215) { - if (averageDuration_2 <= -0.5975858867168427) { - if (maxDuration_2 <= -0.6773234009742737) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7233274579048157) { - if (averageDuration_2 <= -0.5371653437614441) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.43006590008735657) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.35924243927001953) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5309438407421112) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.49216729402542114) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5913253426551819) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.23222923278808594) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.7111433446407318) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.5325217843055725) { - if (averageDuration_2 <= -0.5971518456935883) { - if (maxDuration_2 <= -0.5827095806598663) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4056427478790283) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27833035588264465) { - if (maxDuration_2 <= -0.6454672515392303) { - if (averageDuration_2 <= -0.6022332906723022) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (averageDuration_2 <= -0.6186088025569916) { - if (maxDuration_2 <= -0.6766547858715057) { - if (averageDuration_2 <= -0.6437556147575378) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1201142780482769) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41131511330604553) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5364763289690018) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6195144653320312) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.49299095571041107) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6415844857692719) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6260719299316406) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4396364092826843) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48652738332748413) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (maxDuration_2 <= -0.6298075914382935) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4331739842891693) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7478503584861755) { - if (maxDuration_2 <= -0.5732856392860413) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5805055797100067) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485036849975586) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.5585563480854034) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (maxDuration_2 <= -0.5671309232711792) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.585450142621994) { - if (averageDuration_2 <= -0.5500621795654297) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5785264074802399) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (averageDuration_2 <= -0.5830569267272949) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485168278217316) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0803013602271676) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.5522496700286865) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (maxDuration_2 <= -0.41487836837768555) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.6467221975326538) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5366165935993195) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (maxDuration_2 <= -0.4236970692873001) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6700685620307922) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8278171420097351) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2507883459329605) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5487158894538879) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.514430820941925) { - if (averageDuration_2 <= -0.5451783239841461) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - if (averageDuration_2 <= -0.5507667660713196) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.44435377418994904) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5573250651359558) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1838471032679081) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.596017450094223) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5346470773220062) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8750398457050323) { - if (numDurations_2 <= -0.6989187151193619) { - if (maxDuration_2 <= -0.22777052223682404) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.972898542881012) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5845165550708771) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.399220049381256) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6483140885829926) { - if (averageDuration_2 <= -0.6634586155414581) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6414876878261566) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5942731201648712) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2129421830177307) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7056423723697662) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2873587608337402) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.470812126994133) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6307599544525146) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5706699192523956) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0856215953826904) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.767348438501358) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9372516572475433) { - if (maxDuration_2 <= -0.6185142993927002) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9083563983440399) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7598126232624054) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { - if (maxDuration_2 <= -0.5063439011573792) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (averageDuration_2 <= -0.5468631684780121) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9630212187767029) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.19196251034736633) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6257500648498535) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.6275864839553833) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8962610960006714) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485578656196594) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (numDurations_2 <= 1.008537232875824) { - if (maxDuration_2 <= -0.14342425018548965) { - if (numDurations_2 <= 0.43938523530960083) { - if (maxDuration_2 <= -0.21614809334278107) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794910855591297) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7120539247989655) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6087577939033508) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (maxDuration_2 <= -0.682690292596817) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4900243580341339) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9355016946792603) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (maxDuration_2 <= -0.4319891929626465) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { - if (averageDuration_2 <= -0.5210753977298737) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (averageDuration_2 <= -0.585249125957489) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8006477653980255) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0362975001335144) { - if (averageDuration_2 <= -0.5741309523582458) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.5659933388233185) { - if (averageDuration_2 <= -0.7179114520549774) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5983854234218597) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6374053657054901) { - if (averageDuration_2 <= -0.520757406949997) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4125160872936249) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9024714231491089) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6655683517456055) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.41851530969142914) { - if (maxDuration_2 <= -0.726186603307724) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6629176735877991) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (maxDuration_2 <= -0.4389185607433319) { - if (numDurations_2 <= -1.837222695350647) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (maxDuration_2 <= -0.5597861707210541) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5338271260261536) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.5414673388004303) { - if (averageDuration_2 <= -0.6014557182788849) { - if (averageDuration_2 <= -0.6624838709831238) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6941531598567963) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7770487666130066) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9014868140220642) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.15357730910182) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7702146768569946) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6734192073345184) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.743566632270813) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5177218914031982) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6351950466632843) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485619187355042) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8021135926246643) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7406646609306335) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7139269709587097) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6746354103088379) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.7505207359790802) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7699485719203949) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - if (maxDuration_2 <= -0.6585537493228912) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.09995615109801292) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9031726717948914) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.6200547516345978) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4592435210943222) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484660744667053) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485881745815277) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.8960750997066498) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8728941977024078) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.6590854525566101) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (averageDuration_2 <= -0.610890656709671) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6037259697914124) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.552806168794632) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6184648275375366) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6293505430221558) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40446633100509644) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6927808225154877) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.2328837439417839) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.43991389870643616) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486139237880707) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.6491851210594177) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5502419471740723) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.6018134653568268) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748531848192215) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (averageDuration_2 <= -0.6191984713077545) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5572963654994965) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5861019790172577) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6626396477222443) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6078225374221802) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.40805475413799286) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522207856178284) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.576707124710083) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5866127014160156) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7098152935504913) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485046684741974) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.520365834236145) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5643603205680847) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7258638441562653) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.740404486656189) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485131919384003) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5550532639026642) { - if (maxDuration_2 <= -0.6149559915065765) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - if (averageDuration_2 <= -0.5808843076229095) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.36921538412570953) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6322320103645325) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (maxDuration_2 <= -0.5984604358673096) { - if (averageDuration_2 <= -0.5512113869190216) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.04984685266390443) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485862672328949) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (averageDuration_2 <= -0.597943514585495) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6107260584831238) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (averageDuration_2 <= -0.5599744915962219) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.2714780643582344) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.49900294840335846) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5330140292644501) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485817074775696) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5982114970684052) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5790416300296783) { - if (averageDuration_2 <= -0.5644314885139465) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6182861328125) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6995039582252502) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.7111433446407318) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.5764604806900024) { - if (maxDuration_2 <= -0.605121374130249) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7591287791728973) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4939318895339966) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6701739728450775) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6028318107128143) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.532272607088089) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6183344423770905) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.41205063462257385) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.2223153114318848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { - if (maxDuration_2 <= -0.4491785317659378) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (averageDuration_2 <= -0.5576899647712708) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6411390900611877) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485213279724121) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6526772081851959) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (averageDuration_2 <= -0.6330696642398834) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5661900639533997) { - if (averageDuration_2 <= -0.5864149928092957) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.4960829168558121) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (averageDuration_2 <= -0.556185781955719) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485407888889313) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8572129905223846) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.3921169638633728) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6735976934432983) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4611380845308304) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5642342269420624) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6537365913391113) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349805697799) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - if (maxDuration_2 <= -0.44838833808898926) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6914373338222504) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (averageDuration_2 <= -0.5469672679901123) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.5165861546993256) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5911261439323425) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7472980916500092) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.34113065898418427) { - if (numDurations_2 <= -1.2680706679821014) { - if (maxDuration_2 <= -0.7495760023593903) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8090662956237793) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.23433195054531097) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6742688417434692) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.00141179561615) { - if (numDurations_2 <= 1.008537232875824) { - if (numDurations_2 <= -0.12976674735546112) { - if (maxDuration_2 <= -0.5126476734876633) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.6859812140464783) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.061686933040619) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6398320496082306) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0598382949829102) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7172970473766327) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0345925092697144) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6395599246025085) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.5678352415561676) { - if (averageDuration_2 <= -0.605718731880188) { - if (maxDuration_2 <= -0.6316083371639252) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - if (averageDuration_2 <= -0.6518807709217072) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40861111879348755) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6253732442855835) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (maxDuration_2 <= -0.6536909341812134) { - if (averageDuration_2 <= -0.6893901526927948) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42184053361415863) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5066401958465576) { - if (maxDuration_2 <= -0.7556417882442474) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.498565211892128) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.42411546409130096) { - if (averageDuration_2 <= -0.6865964829921722) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.6445934474468231) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.49230001866817474) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6678047180175781) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5398352146148682) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (averageDuration_2 <= -0.6477979123592377) { - if (maxDuration_2 <= -0.7091670334339142) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5645840764045715) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.6981422305107117) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6272600889205933) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (averageDuration_2 <= -0.7003393471240997) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.41999803483486176) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.061789870262146) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3741445541381836) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - if (averageDuration_2 <= -0.6289122998714447) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5422446727752686) { - if (maxDuration_2 <= -0.6622742712497711) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6440703868865967) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.41004645824432373) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5421479642391205) { - if (averageDuration_2 <= -0.6175379157066345) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.6597008109092712) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.35844261944293976) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5029757618904114) { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.6421452164649963) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.43551841378211975) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5787990689277649) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4371054023504257) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (maxDuration_2 <= -0.6162703335285187) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.5757979452610016) { - if (maxDuration_2 <= -0.5782268643379211) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486106753349304) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.7768075168132782) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5214055180549622) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5368035733699799) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40317757427692413) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6583429574966431) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (maxDuration_2 <= -0.6474706828594208) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4809093326330185) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.785048633813858) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5809987187385559) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.41081346571445465) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5946136116981506) { - if (maxDuration_2 <= -0.6137528121471405) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485660016536713) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6585428714752197) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6874723732471466) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5693450272083282) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5880981981754303) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.44632408022880554) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.594263881444931) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.34444981813430786) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4079017639160156) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1967049166560173) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5264497101306915) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.5458243489265442) { - if (maxDuration_2 <= -0.5993368029594421) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7481858432292938) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5868915021419525) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.49191422760486603) { - if (maxDuration_2 <= -0.5460184216499329) { - if (averageDuration_2 <= -0.5909486413002014) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5095407962799072) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5338984727859497) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.39174215495586395) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (averageDuration_2 <= -0.6353524327278137) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.74856898188591) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5755828320980072) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.5242930352687836) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5580313205718994) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5027727484703064) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.47908376157283783) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485332489013672) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.18612299859523773) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.48679912090301514) { - if (maxDuration_2 <= -0.5508838891983032) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.47643306851387024) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486082315444946) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.061824679374694824) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48094354569911957) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40606094896793365) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5451184511184692) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4485495835542679) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.5079343616962433) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.459091380238533) { - if (maxDuration_2 <= -0.5443013310432434) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.2951493263244629) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (maxDuration_2 <= -0.7598031461238861) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7475833892822266) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (averageDuration_2 <= -0.7109265625476837) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4185460954904556) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5985917150974274) { - if (maxDuration_2 <= -0.3784303367137909) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5767474174499512) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (averageDuration_2 <= -0.5898222625255585) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.10193079710006714) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.19134365767240524) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.650122344493866) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4479955583810806) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28140027821063995) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.383526086807251) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4492497593164444) { - if (numDurations_2 <= -1.837222695350647) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5978890359401703) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.08315486088395119) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 1.5776891708374023) { - if (numDurations_2 <= -1.837222695350647) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4633228927850723) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (averageDuration_2 <= -0.6963796317577362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17047882080078125) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2071799710392952) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6941463351249695) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5255636870861053) { - if (maxDuration_2 <= -0.5394283831119537) { - if (averageDuration_2 <= -0.6123175024986267) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.511682540178299) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485400140285492) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485432326793671) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5043495297431946) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.633042961359024) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6224579513072968) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.05594206787645817) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - if (averageDuration_2 <= -0.6095631718635559) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6031866371631622) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172387123108) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4012703001499176) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8568866550922394) { - if (maxDuration_2 <= -0.6382971704006195) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484807074069977) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.8165296912193298) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5110880434513092) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.33234161138534546) { - if (averageDuration_2 <= -0.6279172599315643) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48621073365211487) { - if (maxDuration_2 <= -0.6418150663375854) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.5762304663658142) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.35096926987171173) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9410466551780701) { - if (numDurations_2 <= 1.2931131720542908) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6238240599632263) { - if (averageDuration_2 <= -0.6304374039173126) { - if (averageDuration_2 <= -0.6305539309978485) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1005992889404297) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.8211486339569092) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0994991064071655) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1424911804497242) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5841317474842072) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= -0.12976674735546112) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6542835533618927) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5831116437911987) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9211200475692749) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0981878638267517) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (numDurations_2 <= -1.2680706679821014) { - if (averageDuration_2 <= -0.5648576617240906) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.14984966069459915) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0574679374694824) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965908551588655) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.8211486339569092) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9750412702560425) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.15082854684442282) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7469054460525513) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7356725037097931) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6677635610103607) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9177530109882355) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5682734847068787) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9457249045372009) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6293622553348541) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6325351297855377) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5895840227603912) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0103041529655457) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= -0.6989187151193619) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9852869808673859) { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485602796077728) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6489087641239166) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8934656977653503) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.7098634541034698) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.036111831665039) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485472857952118) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9295522570610046) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5339083969593048) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0688284635543823) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.7776155769824982) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6109642684459686) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - if (averageDuration_2 <= -0.5401910245418549) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4740087240934372) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5701518654823303) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7403310239315033) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9199309349060059) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5308011174201965) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2498842068016529) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0337629318237305) { - if (averageDuration_2 <= -0.7030116021633148) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486106753349304) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5017267167568207) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (maxDuration_2 <= -0.5441063046455383) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4029839485883713) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9040396511554718) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.6129928827285767) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9740192592144012) { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1211307048797607) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5457411110401154) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485465109348297) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.5942600071430206) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9761590659618378) { - if (maxDuration_2 <= -0.45941825211048126) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 0.439385250210762) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (maxDuration_2 <= -0.5178372859954834) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5744504630565643) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5607343018054962) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5259328782558441) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8766833245754242) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.20753058046102524) { - if (maxDuration_2 <= -0.4275569021701813) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5602551400661469) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.5871747434139252) { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5413225889205933) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.42498302459716797) { - if (maxDuration_2 <= -0.1784287393093109) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.01564949657768011) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6168189346790314) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6790743172168732) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5551392734050751) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6783662736415863) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.5899710655212402) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0803013602271676) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5143053084611893) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.579148679971695) { - if (averageDuration_2 <= -0.6760516464710236) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5288830995559692) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (averageDuration_2 <= -0.5701581537723541) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.272525817155838) { - if (maxDuration_2 <= -0.5195874273777008) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5353161990642548) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (averageDuration_2 <= -0.5475077629089355) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.621362954378128) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5792880952358246) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.10758400056511164) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3468835949897766) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6633188426494598) { - if (maxDuration_2 <= -0.4614797681570053) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3089700937271118) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (maxDuration_2 <= -0.6612407565116882) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3300398290157318) { - if (maxDuration_2 <= -0.49757328629493713) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15521842241287231) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485578656196594) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.5470214486122131) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.12778066843748093) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37474068999290466) { - if (averageDuration_2 <= -0.5727451741695404) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.44540999829769135) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4799879491329193) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5575012266635895) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5254124999046326) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.02006736770272255) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4052685499191284) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1161888241767883) { - if (averageDuration_2 <= -0.5327414274215698) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40609219670295715) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6149024367332458) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (maxDuration_2 <= -0.6303115785121918) { - if (averageDuration_2 <= -0.6150277256965637) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.07682698452845216) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6403545141220093) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2544964998960495) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5272620618343353) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.5343095660209656) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.31468772888183594) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 0.43938517570495605) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.34311598539352417) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.04233570955693722) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.09231467545032501) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7452520728111267) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.8238902390003204) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.21396401524543762) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8508541285991669) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3640372157096863) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (numDurations_2 <= 0.43938523530960083) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (averageDuration_2 <= -0.6898009181022644) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2542356848716736) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6032586395740509) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.8184602558612823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.6101516485214233) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.13585316389799118) { - if (averageDuration_2 <= -0.6986209750175476) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.325019896030426) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4068748503923416) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.6047946810722351) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6055684387683868) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.34697169065475464) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6567239463329315) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.038201725110411644) { - if (averageDuration_2 <= -0.7078695595264435) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.45547060668468475) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.6924512386322021) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.554705798625946) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2668192833662033) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6001040041446686) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4804098457098007) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.048951586708426476) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (maxDuration_2 <= -0.7167750597000122) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5858961641788483) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (maxDuration_2 <= -0.6378109753131866) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5424762666225433) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4065143018960953) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5802216231822968) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.6085640490055084) { - if (maxDuration_2 <= -0.7004444301128387) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.470812126994133) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7362076938152313) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.5702382326126099) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3191536068916321) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748468279838562) { - if (maxDuration_2 <= -0.5911916792392731) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.48627130687236786) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7426013946533203) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6676006019115448) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7244588136672974) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5432488024234772) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5292292237281799) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.588408425450325) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (averageDuration_2 <= -0.5283207595348358) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.20815537124872208) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.5599989295005798) { - if (maxDuration_2 <= -0.576337456703186) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5747544467449188) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5682758092880249) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486014664173126) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485822141170502) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5735616087913513) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.5616148710250854) { - if (averageDuration_2 <= -0.601123034954071) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32193659245967865) { - if (maxDuration_2 <= -0.6446897685527802) { - if (averageDuration_2 <= -0.6165066957473755) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8131964206695557) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.70070019364357) { - if (averageDuration_2 <= -0.6616089344024658) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4859745353460312) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.644880473613739) { - if (averageDuration_2 <= -0.6873809695243835) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6631074547767639) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.6133298575878143) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (averageDuration_2 <= -0.6042291522026062) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4051479548215866) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.44035471975803375) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6700165867805481) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.44464975595474243) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5581760108470917) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7142362892627716) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6289109289646149) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5403825044631958) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5714545845985413) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6713647842407227) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5491890609264374) { - if (maxDuration_2 <= -0.619600772857666) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6781724691390991) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40903517603874207) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.6256894767284393) { - if (maxDuration_2 <= -0.6465968191623688) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (averageDuration_2 <= -0.5807237327098846) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4406105577945709) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (numDurations_2 <= 0.43938523530960083) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.04633626714348793) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485619187355042) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5676531195640564) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484703958034515) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.45388931035995483) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.5068480670452118) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5819621384143829) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5245867073535919) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.5854982137680054) { - if (maxDuration_2 <= -0.6158956289291382) { - if (averageDuration_2 <= -0.618424117565155) { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.042526408564299345) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.12119465321302414) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4471616744995117) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.8165296912193298) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5848534405231476) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.31118519604206085) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.6401105225086212) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7203609049320221) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5040415525436401) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8468363583087921) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.1602861285209656) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.024465138092637062) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.18479663133621216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (numDurations_2 <= -1.837222695350647) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4730672836303711) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4553234577178955) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5851899683475494) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6681893169879913) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7882016897201538) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3109428733587265) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { - if (averageDuration_2 <= -0.6290301084518433) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (maxDuration_2 <= -0.7581214606761932) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { - if (averageDuration_2 <= -0.7083679437637329) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4910467863082886) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8535929024219513) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5749009251594543) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12006822228431702) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484993636608124) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6496344804763794) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - if (maxDuration_2 <= -0.7137130796909332) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4290008693933487) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.502291738986969) { - if (averageDuration_2 <= -0.7152606546878815) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.7135182917118073) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7803255617618561) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.6566592454910278) { - if (averageDuration_2 <= -0.6294673979282379) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.559353768825531) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4586620181798935) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5487784445285797) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.8971228301525116) { - if (maxDuration_2 <= -0.7519009411334991) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3090042918920517) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486269176006317) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7480176985263824) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.735450953245163) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (averageDuration_2 <= -0.6348683536052704) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5965524017810822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.52269446849823) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.31715817749500275) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5557147562503815) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.31765952706336975) { - if (maxDuration_2 <= -0.6758417785167694) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.6530837714672089) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.46255192160606384) { - if (maxDuration_2 <= -0.7342659533023834) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= -0.12976674735546112) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6724081337451935) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5124752521514893) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.6895538568496704) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7037407457828522) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.49726374447345734) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484878599643707) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.44689221680164337) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.31357966363430023) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484384477138519) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.6448163986206055) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5043505430221558) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6094005405902863) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.620573103427887) { - if (averageDuration_2 <= -0.7007867693901062) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5457299947738647) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6447851359844208) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (numDurations_2 <= 0.43938523530960083) { - if (maxDuration_2 <= -0.715828001499176) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.184060700237751) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.23817872256040573) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.6290706396102905) { - if (maxDuration_2 <= -0.7308543622493744) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6547055542469025) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485988736152649) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7353141903877258) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.6454848647117615) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5412477850914001) { - if (averageDuration_2 <= -0.5934551358222961) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5178772509098053) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.39365823566913605) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.19196250289678574) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6746354103088379) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.76400426030159) { - if (averageDuration_2 <= -0.6174235939979553) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6081715524196625) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748590350151062) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5016510188579559) { - if (maxDuration_2 <= -0.6520800292491913) { - if (maxDuration_2 <= -0.6585866510868073) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5579375922679901) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7149111032485962) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.5994527637958527) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.10048868134617805) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4595942944288254) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4744039326906204) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (maxDuration_2 <= -0.6280599534511566) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5274279117584229) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.43255744874477386) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6205936670303345) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.47046665847301483) { - if (maxDuration_2 <= -0.2748406231403351) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6053260266780853) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6008701026439667) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.22330547124147415) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.6061720848083496) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.43165072798728943) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (maxDuration_2 <= -0.5724497139453888) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8727467060089111) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.515039712190628) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6484903991222382) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6078263521194458) { - if (averageDuration_2 <= -0.622720867395401) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.19340523332357407) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.5759347677230835) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (maxDuration_2 <= -0.5912752449512482) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6705639064311981) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.38828402757644653) { - if (averageDuration_2 <= -0.6015032827854156) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5773809254169464) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4022064357995987) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6693777441978455) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6506822407245636) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486122846603394) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.43551841378211975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6147647202014923) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6135873198509216) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.654521107673645) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4159712791442871) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486025393009186) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.5367083847522736) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6667650938034058) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.21927902102470398) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4579868018627167) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.66371750831604) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.6333103179931641) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485212981700897) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748604953289032) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6182128190994263) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6922973990440369) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (maxDuration_2 <= -0.5866580903530121) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7142362892627716) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5502391755580902) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6393870711326599) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7099716067314148) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486003637313843) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.6417466700077057) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6366530060768127) { - if (maxDuration_2 <= -0.608241617679596) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4293956160545349) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5718539357185364) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40134064853191376) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6216707229614258) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.713463544845581) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.513492077589035) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5331782698631287) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6629994213581085) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.6264947950839996) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4017510265111923) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6832115352153778) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5383094549179077) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6058141887187958) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (maxDuration_2 <= -0.6113214790821075) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3949257582426071) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (maxDuration_2 <= -0.6155282557010651) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.47968408465385437) { - if (averageDuration_2 <= -0.5728826224803925) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5770086050033569) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9917370676994324) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5146026313304901) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.5330525636672974) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5107685923576355) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40300559997558594) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5584996342658997) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5423844158649445) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (averageDuration_2 <= -0.5568572282791138) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638475418091) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5662193596363068) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7420831322669983) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9386163949966431) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6286956667900085) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3949257582426071) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (maxDuration_2 <= -0.6660833954811096) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485785782337189) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5398869812488556) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5224565863609314) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (maxDuration_2 <= -0.5859920382499695) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.6133907437324524) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606539070606) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6859308779239655) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.1516360640525818) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6380309760570526) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6397914290428162) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6532373130321503) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5714013576507568) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5694357454776764) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5583223104476929) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.5707395970821381) { - if (maxDuration_2 <= -0.6094370782375336) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6915875673294067) { - if (averageDuration_2 <= -0.5813417434692383) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5518341362476349) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5493275821208954) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8231029808521271) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5616311430931091) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486079931259155) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6204337477684021) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.581122100353241) { - if (averageDuration_2 <= -0.5817528665065765) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5857867896556854) { - if (averageDuration_2 <= -0.5835716128349304) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5786197185516357) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4693758487701416) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6720173954963684) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5457231998443604) { - if (maxDuration_2 <= -0.5849308669567108) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5526072978973389) { - if (maxDuration_2 <= -0.6069222390651703) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6370143890380859) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.5708008408546448) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485783100128174) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.40665461868047714) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.9083105623722076) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5405711233615875) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.4807713031768799) { - if (averageDuration_2 <= -0.5496420860290527) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5044622421264648) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (averageDuration_2 <= -0.5701306462287903) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6795294284820557) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (averageDuration_2 <= -0.5370084345340729) { - if (averageDuration_2 <= -0.5404379665851593) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5220567882061005) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.44767098128795624) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5425611734390259) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484880089759827) { - if (averageDuration_2 <= -0.5527431964874268) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5708175152540207) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= 0.43938523530960083) { - if (maxDuration_2 <= -0.6434739828109741) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9179660081863403) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1523250341415405) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7255125045776367) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6893866956233978) { - if (maxDuration_2 <= -0.8133594691753387) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.36309659481048584) { - if (numDurations_2 <= -1.837222695350647) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6731290519237518) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486057877540588) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6867575943470001) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.7307353019714355) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7157882153987885) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7828660309314728) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15674817562103271) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.8463466763496399) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8120512962341309) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.12434348464012146) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42685945332050323) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748557060956955) { - if (maxDuration_2 <= -0.7677456140518188) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.14801420271396637) { - if (averageDuration_2 <= -0.5637625455856323) { - if (averageDuration_2 <= -0.7082066237926483) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486269176006317) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.7201589345932007) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.2328837439417839) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7369267344474792) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9049053490161896) { - if (maxDuration_2 <= -0.20259317755699158) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3468298316001892) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6966659724712372) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= -0.6989187151193619) { - if (maxDuration_2 <= -0.6178127527236938) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.74850994348526) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - if (maxDuration_2 <= -0.20296283066272736) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8983940780162811) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5048615634441376) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2180181741714478) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5492505431175232) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403679728507996) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.42564503848552704) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.10248609259724617) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5433846414089203) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9222651720046997) { - if (numDurations_2 <= 1.008537232875824) { - if (averageDuration_2 <= -0.6975576281547546) { - if (maxDuration_2 <= -0.6935478150844574) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.590107798576355) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6772269904613495) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6784807443618774) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0474528670310974) { - if (averageDuration_2 <= -0.6112178266048431) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.40660393238067627) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3825113922357559) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.627986490726471) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6279688477516174) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5605310201644897) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6281616985797882) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.6496928334236145) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0098888874053955) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.683344155550003) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.27381957322359085) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.4462507665157318) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4000002592802048) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8399596810340881) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.31720077246427536) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.2877315431833267) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (averageDuration_2 <= -0.34540486335754395) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7017553150653839) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9205435514450073) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.19148658961057663) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0940665006637573) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.13630641996860504) { - if (averageDuration_2 <= -0.35186243057250977) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.2410571128129959) { - if (averageDuration_2 <= -0.3510347306728363) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.49503903090953827) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.49333688616752625) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.4461781978607178) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.37599845230579376) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7415765225887299) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8383578360080719) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.47954896092414856) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.642632395029068) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (averageDuration_2 <= -0.4210948646068573) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.44387005269527435) { - if (averageDuration_2 <= -0.48302602767944336) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.272525817155838) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7935082018375397) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7152048349380493) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291666150093079) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.43829044699668884) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.1516360640525818) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0673220781609416) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8891547918319702) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7404561340808868) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (averageDuration_2 <= -0.41596120595932007) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8743529617786407) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.4564676433801651) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4851799011230469) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (maxDuration_2 <= -0.5305514335632324) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.4358919858932495) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.3944251388311386) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17146595567464828) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.4069526493549347) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8995382487773895) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.11026938259601593) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.3778313398361206) { - if (averageDuration_2 <= -0.494231253862381) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.49228665232658386) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5896517336368561) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.30096161365509033) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.37698450684547424) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4443999081850052) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (averageDuration_2 <= -0.4630194902420044) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.38063959777355194) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.47397103905677795) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.59116330742836) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - if (maxDuration_2 <= -0.5003565847873688) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7525697350502014) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.27601249516010284) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (maxDuration_2 <= -0.5653911530971527) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5609693825244904) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (averageDuration_2 <= -0.4999157041311264) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48056595027446747) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485781610012054) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.42769622802734375) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (averageDuration_2 <= -0.4851462095975876) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.1860547438263893) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.503919243812561) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7661499083042145) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4706431180238724) { - if (maxDuration_2 <= -0.48763492703437805) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.20744965970516205) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.47474098205566406) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.4869600981473923) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5708175152540207) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522207856178284) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089243412018) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.17529451102018356) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21807967126369476) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149006992578506) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.3601253926753998) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.04249554127454758) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7162122130393982) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.35286179184913635) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.31029582023620605) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06011745519936085) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.3663276731967926) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1259683407843113) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (maxDuration_2 <= -0.2410849779844284) { - if (averageDuration_2 <= -0.34614574909210205) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.28263644874095917) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.626276284456253) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6430130004882812) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8410999476909637) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2552844136953354) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9045834839344025) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.272525817155838) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5827533602714539) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - if (maxDuration_2 <= -0.4003532975912094) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7266887128353119) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.4546778202056885) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9977320432662964) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.4583968222141266) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.528881847858429) { - if (maxDuration_2 <= -0.39596420526504517) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6678047180175781) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.3688119053840637) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.46508629620075226) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4043523669242859) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.6036120057106018) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5994037836790085) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.3829658776521683) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5149401277303696) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6164318025112152) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7718425691127777) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.48109008371829987) { - if (averageDuration_2 <= -0.5132443308830261) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.4969526380300522) { - if (maxDuration_2 <= -0.5544624924659729) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.4267718493938446) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.49063943326473236) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0057587623596191) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (averageDuration_2 <= -0.38895364105701447) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9100799858570099) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (maxDuration_2 <= -0.4638276696205139) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.4844638705253601) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07414579764008522) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15412722527980804) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (maxDuration_2 <= -0.579267680644989) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (averageDuration_2 <= -0.3726997375488281) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - if (averageDuration_2 <= -0.4388546645641327) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7991330921649933) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.43590258061885834) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7464483678340912) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5735138654708862) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.767071932554245) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.723993718624115) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - if (averageDuration_2 <= -0.493863046169281) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748504251241684) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7409085631370544) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7521025836467743) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.729773759841919) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7778133451938629) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485854625701904) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.517627090215683) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485310733318329) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.4762718379497528) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.46599817276000977) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.377871572971344) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5336331725120544) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2204464077949524) { - if (averageDuration_2 <= -0.4575706869363785) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.3670579642057419) { - if (maxDuration_2 <= -0.5299789607524872) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3480940908193588) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (averageDuration_2 <= -0.40196920931339264) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32685886323451996) { - if (averageDuration_2 <= -0.41820454597473145) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1161888539791107) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.33038510382175446) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.36887556314468384) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2201223149895668) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.4013080447912216) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485660016536713) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2026185691356659) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8007532954216003) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2664951980113983) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.3851279765367508) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.743062436580658) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.751629501581192) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748591423034668) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.3785570114850998) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.23222923278808594) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485180795192719) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.010079063475131989) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.36808939278125763) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239316046238) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (averageDuration_2 <= -0.4779582768678665) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.19196250289678574) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.35226769745349884) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.26787397265434265) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4233684539794922) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (averageDuration_2 <= -0.5028457939624786) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.49016015231609344) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.46725763380527496) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5059376657009125) { - if (maxDuration_2 <= -0.6131221652030945) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5076574981212616) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1585126891732216) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9132877290248871) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.37163498997688293) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3141997307538986) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21854796260595322) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.09460854530334473) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.40125441551208496) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6049173176288605) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.4752926826477051) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7385323941707611) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9213506281375885) { - if (averageDuration_2 <= -0.426745668053627) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.055704932659864426) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5342630743980408) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5708175152540207) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.17337137460708618) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.48006628453731537) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.012840613257139921) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (averageDuration_2 <= -0.45031706988811493) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4091905653476715) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7835126519203186) { - if (maxDuration_2 <= -0.4653852581977844) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.10502529516816139) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2845323234796524) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.16484689712524414) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6682112514972687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.4631006270647049) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.41155287623405457) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.03138184733688831) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5259695649147034) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.10861397534608841) { - if (averageDuration_2 <= -0.39306725561618805) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.32002659142017365) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.39124275743961334) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.08298928290605545) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9677406549453735) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7777889370918274) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (averageDuration_2 <= -0.3684269189834595) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.10438846424221992) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (averageDuration_2 <= -0.3936549574136734) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.362395241856575) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7681441307067871) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093146696686745) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.13112079352140427) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3652183711528778) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2574236989021301) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.33562271296977997) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118843227625) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.660483181476593) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.506536453962326) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.32608775794506073) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (maxDuration_2 <= -0.4119150638580322) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.44431379437446594) { - if (averageDuration_2 <= -0.34741465747356415) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776627898216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.3507463037967682) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.21237558871507645) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.362347275018692) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7093702256679535) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (averageDuration_2 <= -0.4503464996814728) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2983732968568802) { - if (maxDuration_2 <= -0.4048260301351547) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6632714867591858) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (maxDuration_2 <= -0.45629797875881195) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4836314022541046) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5747091472148895) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486074268817902) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748517245054245) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5038794577121735) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - if (maxDuration_2 <= -0.42466969788074493) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1396324560046196) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6700529158115387) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.47315068542957306) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07969395071268082) { - if (averageDuration_2 <= -0.44210630655288696) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.10518838092684746) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.41178272664546967) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40749040246009827) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.3706723004579544) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.50300532579422) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.40446610748767853) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (maxDuration_2 <= -0.46705421805381775) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4970572739839554) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.35793112218379974) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.308582067489624) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.41950754821300507) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.48391093313694) { - if (maxDuration_2 <= -0.2743797153234482) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.03685928788036108) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5232345759868622) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.454201802611351) { - if (averageDuration_2 <= -0.3931693285703659) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484807074069977) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4952777624130249) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.41781623661518097) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (averageDuration_2 <= -0.37019820511341095) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4875843822956085) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.3727445602416992) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.560415506362915) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5791451930999756) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (averageDuration_2 <= -0.42943713068962097) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18633536249399185) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.41728562116622925) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485789656639099) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9901047646999359) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.4269566982984543) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3023456037044525) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6021405160427094) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.16437020152807236) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4807608276605606) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (averageDuration_2 <= -0.45464618504047394) { - if (maxDuration_2 <= -0.4271947890520096) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3698868006467819) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (numDurations_2 <= 0.7239612340927124) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1557164490222931) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41612885892391205) { - if (averageDuration_2 <= -0.40913572907447815) { - if (maxDuration_2 <= -0.4529648423194885) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1408619061112404) { - if (averageDuration_2 <= -0.4314831793308258) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.45960503816604614) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.3762267678976059) { - if (maxDuration_2 <= -0.504226490855217) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6010940968990326) { - if (maxDuration_2 <= -0.3172658085823059) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (averageDuration_2 <= -0.4017970561981201) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4419882595539093) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.5142407417297363) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7865826189517975) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.4972071796655655) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6212486326694489) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.4103454202413559) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7480404376983643) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6729304194450378) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.39219117164611816) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.4125809222459793) { - if (maxDuration_2 <= -0.42406441271305084) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4642833173274994) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5679060518741608) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.04718700051307678) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.29762402176856995) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (averageDuration_2 <= -0.501738578081131) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485513687133789) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.49111516773700714) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (averageDuration_2 <= -0.42941662669181824) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5418379604816437) { - if (averageDuration_2 <= -0.4747678190469742) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5410770773887634) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32124680280685425) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726021289825) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (averageDuration_2 <= -0.4440923184156418) { - if (maxDuration_2 <= -0.5019851177930832) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4398898780345917) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9081358909606934) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.49508771300315857) { - if (maxDuration_2 <= -0.48788562417030334) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4761110693216324) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4896344691514969) { - if (averageDuration_2 <= -0.4507438540458679) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.41779862344264984) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5499401986598969) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.570503443479538) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.43093550205230713) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.25616973638534546) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.24880194664001465) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.03453083150088787) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7461006939411163) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4127431809902191) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.45739488303661346) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.22403627634048462) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (averageDuration_2 <= -0.36030514538288116) { - if (maxDuration_2 <= -0.3840097486972809) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17149866372346878) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.43955984711647034) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.3870605528354645) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.43470507860183716) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.3862901031970978) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.46103645861148834) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41658972203731537) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22293802350759506) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6304048895835876) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21000273525714874) { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.2663256376981735) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.719666987657547) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2784240245819092) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485543489456177) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484888434410095) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20849379897117615) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.5191213488578796) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4678848683834076) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.5091754198074341) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.41808490455150604) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485456764698029) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485781610012054) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (maxDuration_2 <= -0.2799491658806801) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.39570824801921844) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.056119196116924286) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6769475638866425) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.075559675693512) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.47905300557613373) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5281854569911957) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.44329987466335297) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5711765885353088) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (averageDuration_2 <= -0.4733972102403641) { - if (averageDuration_2 <= -0.5068470537662506) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6933205425739288) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4892762154340744) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4130202829837799) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.3620969206094742) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.16565268486738205) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5786398351192474) { - if (averageDuration_2 <= -0.45893630385398865) { - if (maxDuration_2 <= -0.5071670413017273) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.25047922134399414) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8383578360080719) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2493586465716362) { - if (averageDuration_2 <= -0.4554085284471512) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (maxDuration_2 <= -0.46151284873485565) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.4036356508731842) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.3999886214733124) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6674900352954865) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.13103439658880234) { - if (averageDuration_2 <= -0.43849073350429535) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5540191829204559) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.179450161755085) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4265744686126709) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.4285469055175781) { - if (maxDuration_2 <= -0.39530307054519653) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.23222923278808594) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.18543855100870132) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5626822113990784) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.49787428975105286) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.040106117725372314) { - if (maxDuration_2 <= -0.15610798448324203) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6746149063110352) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.4630049765110016) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.47228793799877167) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2534039169549942) { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.46695293486118317) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.29987315833568573) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.02006736397743225) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.10769771784543991) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5740419030189514) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.424423485994339) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5884684920310974) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.23255515843629837) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.43551841378211975) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.44160230457782745) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6087464392185211) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12730631977319717) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4946414828300476) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6059083044528961) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6941799521446228) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5457775890827179) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1150943897664547) { - if (averageDuration_2 <= -0.44752050936222076) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2644287645816803) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.4905020147562027) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.41398613154888153) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4533536732196808) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4850296974182129) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.419027179479599) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6164864003658295) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0031615342013537884) { - if (maxDuration_2 <= -0.4362060874700546) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.45395445823669434) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0016115749604068696) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.328902930021286) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.691698431968689) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.16084719449281693) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4556976854801178) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3992614150047302) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.5179385542869568) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0943399928510189) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.15231416374444962) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5621752440929413) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.44039031863212585) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3822551816701889) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5433201491832733) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.49638791382312775) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3995536118745804) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4145127087831497) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.19224528968334198) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.49668678641319275) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.018273180350661278) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2731478065252304) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.4519044905900955) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6990666389465332) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8132957518100739) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.20161471515893936) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.03642451763153076) { - if (averageDuration_2 <= -0.4608576148748398) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.4528513550758362) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4229937791824341) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.4202948212623596) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1469392403960228) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4582834839820862) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.4660760760307312) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4944300204515457) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.15142468363046646) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09841525554656982) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.244485005736351) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.43423469364643097) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.46017545461654663) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4411269873380661) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - if (maxDuration_2 <= -0.49218378961086273) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.48566870391368866) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48042768239974976) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1080469973385334) { - if (averageDuration_2 <= -0.3567211478948593) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.10004199296236038) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.10565562918782234) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.37569865584373474) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5894407033920288) { - if (averageDuration_2 <= -0.36318132281303406) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089094400406) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5873809158802032) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.16533751785755157) { - if (maxDuration_2 <= -0.3092878609895706) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.18742173165082932) { - if (averageDuration_2 <= -0.37049008905887604) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.44659511744976044) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6546749770641327) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.39335623383522034) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.025132120586931705) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5923017263412476) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.11044968664646149) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5148386359214783) { - if (averageDuration_2 <= -0.3809855282306671) { - if (maxDuration_2 <= -0.507296234369278) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.0901434333063662) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.29907163977622986) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1446518450975418) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8481956124305725) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456615447998) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2874078154563904) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2521565333008766) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.3512396067380905) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5290227234363556) { - if (maxDuration_2 <= -0.32623156905174255) { - if (averageDuration_2 <= -0.3565983325242996) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.43551841378211975) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.18799541145563126) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6498253643512726) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9475547671318054) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07784419879317284) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08636709302663803) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4425090402364731) { - if (averageDuration_2 <= -0.3749467134475708) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.35074035823345184) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - if (maxDuration_2 <= -0.43764713406562805) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.49329546093940735) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.3715676963329315) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6401868760585785) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4230690002441406) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (maxDuration_2 <= -0.4030809551477432) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (maxDuration_2 <= -0.4536639153957367) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4366084486246109) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.477387934923172) { - if (averageDuration_2 <= -0.3590942770242691) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2776988372206688) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.3570324778556824) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.016184553503990173) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.31715817749500275) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6008574962615967) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5154628753662109) { - if (averageDuration_2 <= -0.38761185109615326) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5854571461677551) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5360842049121857) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.03509561903774738) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9909244477748871) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.645479142665863) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.03151668608188629) { - if (maxDuration_2 <= -0.2715330123901367) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.02706373669207096) { - if (averageDuration_2 <= -0.3614296019077301) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.16825183480978012) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.39569199085235596) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2941809594631195) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6344625651836395) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.3932870477437973) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.40227964520454407) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.17791948467493057) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485261857509613) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6551596224308014) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7208743691444397) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0558820962905884) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485139966011047) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6419090330600739) { - if (averageDuration_2 <= -0.31675757467746735) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485635578632355) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.3034067302942276) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.31897203624248505) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4765326827764511) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7427478432655334) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5333503186702728) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.11648909747600555) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0708580911159515) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485418915748596) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5631608963012695) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5322364568710327) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1978984847664833) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5630575120449066) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5175121128559113) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (averageDuration_2 <= -0.3178412914276123) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0902730822563171) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.2677568793296814) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.45541906356811523) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.3104892373085022) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8331855833530426) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8101078569889069) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2878285348415375) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (averageDuration_2 <= -0.3147650808095932) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.3570113182067871) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2747475504875183) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.3326541930437088) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.16981247812509537) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.54273521900177) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (averageDuration_2 <= -0.3024888038635254) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.30293726921081543) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2529370039701462) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.46095047891139984) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6099193692207336) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4858836680650711) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4537171572446823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0038877129554749) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6403085887432098) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.372219517827034) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6276201903820038) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.2991176098585129) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7371344268321991) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (averageDuration_2 <= -0.2939274162054062) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7419174313545227) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5942821502685547) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.424275666475296) { - if (maxDuration_2 <= -0.42066293954849243) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.405598521232605) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.11151490360498428) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.989253968000412) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486149966716766) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7367870509624481) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6408440172672272) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4892643690109253) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.3139950782060623) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486171722412109) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.30552856624126434) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.30460232496261597) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.4172285199165344) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.2964763939380646) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.33606092631816864) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.32926855981349945) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6817446649074554) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - if (numDurations_2 <= -0.1297668218612671) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7583528161048889) { - if (averageDuration_2 <= -0.31135936081409454) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.34018470346927643) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1614174246788025) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3746485263109207) { - if (averageDuration_2 <= -0.2896265983581543) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.4416525363922119) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.31715816631913185) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3067418336868286) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.47083306312561035) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (maxDuration_2 <= -0.4128117561340332) { - if (averageDuration_2 <= -0.3376539796590805) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3031547963619232) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08689345419406891) { - if (averageDuration_2 <= -0.3356188088655472) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.1591067910194397) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (averageDuration_2 <= -0.29920725524425507) { - if (maxDuration_2 <= -0.39796750247478485) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (averageDuration_2 <= -0.31926129758358) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.01973761059343815) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4675256758928299) { - if (averageDuration_2 <= -0.3103250414133072) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9929423928260803) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7352018058300018) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748537540435791) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485678493976593) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1456533595919609) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5935258269309998) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15680913627147675) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.04596349410712719) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (maxDuration_2 <= -0.41855818033218384) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6563375890254974) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485968470573425) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514787554741) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.01346769742667675) { - if (maxDuration_2 <= -0.390498548746109) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7949601709842682) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.3154606819152832) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.3287476897239685) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7952302098274231) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08151774853467941) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.2979160398244858) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (maxDuration_2 <= -0.47105082869529724) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7183324992656708) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12416355311870575) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (maxDuration_2 <= -0.3431219011545181) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748530238866806) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8599216341972351) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665165930986404) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6495566666126251) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12215658277273178) { - if (maxDuration_2 <= -0.20833201706409454) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089094400406) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6435374021530151) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.19842172414064407) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06969590112566948) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6412895619869232) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6658473610877991) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4883332848548889) { - if (averageDuration_2 <= -0.29506683349609375) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.212310314178467) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7431512773036957) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.30452634394168854) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541325807571) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.11537477001547813) { - if (averageDuration_2 <= -0.3168568015098572) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (averageDuration_2 <= -0.294744148850441) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (maxDuration_2 <= -0.24545379728078842) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7378760874271393) { - if (maxDuration_2 <= -0.23839524388313293) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5999282002449036) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.000891057075932622) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.30530960857868195) { - if (maxDuration_2 <= -0.08422767743468285) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.48441511392593384) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8814854323863983) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5425611734390259) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486155331134796) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.470812126994133) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7405452132225037) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.04867475852370262) { - if (maxDuration_2 <= -0.2602396756410599) { - if (averageDuration_2 <= -0.3177509903907776) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.3514444977045059) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4628470093011856) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6669897437095642) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.02586555667221546) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485204935073853) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.710762083530426) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.2888945937156677) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (averageDuration_2 <= -0.305282860994339) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485489249229431) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.719666987657547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.17324932664632797) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6049166917800903) { - if (averageDuration_2 <= -0.3115391433238983) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486082315444946) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.13514093309640884) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (maxDuration_2 <= -0.41962702572345734) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.3243833929300308) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6832435131072998) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (averageDuration_2 <= -0.3391868770122528) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.048756638541817665) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.45020928978919983) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.26047728955745697) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7389938533306122) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.01992938807234168) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.33988627791404724) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.06831160560250282) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5779412984848022) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5477691292762756) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236781001091003) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.3719669282436371) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.039831243455410004) { - if (maxDuration_2 <= -0.3972887396812439) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.3438810557126999) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.17679756879806519) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2521565333008766) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.16015350818634033) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06850844621658325) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6106472909450531) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6635494530200958) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.19382239133119583) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.48690031468868256) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - if (maxDuration_2 <= -0.3190765976905823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - if (maxDuration_2 <= -0.2309415638446808) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4887588322162628) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.31096629798412323) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8531287908554077) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.2700489014387131) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.020650038495659828) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.23226115852594376) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (maxDuration_2 <= -0.369667187333107) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6987103223800659) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.679982990026474) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15833443403244019) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.471129834651947) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.570559561252594) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.41398029029369354) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.806976318359375) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7733803391456604) { - if (averageDuration_2 <= -0.30801011621952057) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.04985160194337368) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.14670702069997787) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4666711539030075) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4428822845220566) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.4138956069946289) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6050992608070374) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.14580752700567245) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.589937150478363) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.047017522156238556) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.24539043009281158) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3288295269012451) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4168309271335602) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.3191639333963394) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.2211880311369896) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (averageDuration_2 <= -0.3153810650110245) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (maxDuration_2 <= -0.35830044746398926) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.36085793375968933) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4964791536331177) { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.2671917825937271) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.29083825647830963) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8840866684913635) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6136572062969208) { - if (averageDuration_2 <= -0.28967784345149994) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.030796382576227188) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.3483317494392395) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.3091466873884201) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.14336030930280685) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (averageDuration_2 <= -0.35937391221523285) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6205548942089081) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6732939183712006) { - if (averageDuration_2 <= -0.4557391107082367) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7463884353637695) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6468529999256134) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (maxDuration_2 <= -0.21173348277807236) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485678791999817) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.5472673177719116) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.971582442522049) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5858054459095001) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (averageDuration_2 <= -0.47994987666606903) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.952353447675705) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.460571750998497) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1161888241767883) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.08236062154173851) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (maxDuration_2 <= -0.3703991025686264) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6926728188991547) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23677273094654083) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3147457093000412) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.227210633456707) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6073647737503052) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484758198261261) { - if (averageDuration_2 <= -0.5047189593315125) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423399567604065) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1794150397181511) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (averageDuration_2 <= -0.3914089798927307) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1175682544708252) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.7111433446407318) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.511399120092392) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.158347338438034) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.0093110501766205) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32184144854545593) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.539190262556076) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4547124058008194) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.29165515303611755) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2970457226037979) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6735343337059021) { - if (averageDuration_2 <= -0.3668102025985718) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9637999832630157) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - if (averageDuration_2 <= -0.44082432985305786) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8328611850738525) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.35350100696086884) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2541857808828354) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7281917333602905) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.42982448637485504) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.40536922216415405) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.044920265674591) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.4267992824316025) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.039008972235023975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (averageDuration_2 <= -0.3647245615720749) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6461068987846375) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (maxDuration_2 <= -0.5160163044929504) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7280016839504242) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06783053651452065) { - if (maxDuration_2 <= -0.42021968960762024) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2712238281965256) { - if (averageDuration_2 <= -0.3818550556898117) { - if (averageDuration_2 <= -0.48794177174568176) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3879541605710983) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5329106748104095) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (maxDuration_2 <= -0.5539103746414185) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6946929693222046) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8001738786697388) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7385323941707611) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.38631975650787354) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8599216341972351) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.08192503079771996) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5768885910511017) { - if (averageDuration_2 <= -0.46969887614250183) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6494906842708588) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.4711901843547821) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5981233716011047) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.04522705078125) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08277841657400131) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2993634045124054) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.29814137518405914) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1707926988601685) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08189302682876587) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9323183596134186) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.008361813146620989) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.15882298350334167) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8310829102993011) { - if (averageDuration_2 <= -0.45987817645072937) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5259695649147034) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5050472319126129) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.08293446153402328) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.40526340901851654) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4066242426633835) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.045778799802064896) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.266085147857666) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8231558501720428) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.3941274881362915) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07360317558050156) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4479955583810806) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1819828748703003) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.11521785706281662) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7521063089370728) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6042692065238953) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9121025502681732) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.19483810663223267) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1911996677517891) { - if (averageDuration_2 <= -0.3635105937719345) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.36061790585517883) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07640846818685532) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.3654271066188812) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.4280431866645813) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5619236528873444) { - if (averageDuration_2 <= -0.3775222599506378) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.30325064063072205) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.19144360721111298) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6042692065238953) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.01783779449760914) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.51244255900383) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1637340635061264) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1384930983185768) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6465511620044708) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7116492390632629) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6551260054111481) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.09770984947681427) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.7111433446407318) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.4501853287220001) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (averageDuration_2 <= -0.38718122243881226) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.07085730880498886) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.32217201590538025) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (averageDuration_2 <= -0.4106654226779938) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5457653105258942) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.07920760661363602) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.3914494663476944) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.2730184718966484) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.23218537867069244) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8112705945968628) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6908784508705139) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.33865055441856384) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4726920872926712) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.49287670850753784) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5137620866298676) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.32959793508052826) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (maxDuration_2 <= -0.5481662452220917) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4073130637407303) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.3660598695278168) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3646329939365387) { - if (averageDuration_2 <= -0.43427373468875885) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6094579696655273) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.4963194876909256) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.47894246876239777) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.47688962519168854) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7437491118907928) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.39237380027770996) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.06641573272645473) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18190962821245193) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5667342245578766) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9901047646999359) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.38016390800476074) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.74592524766922) { - if (averageDuration_2 <= -0.47020673751831055) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7462577223777771) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.39919283986091614) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.42137348651885986) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.48538437485694885) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.48207370936870575) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09140275791287422) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5791686177253723) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4318486154079437) { - if (averageDuration_2 <= -0.3897954672574997) { - if (maxDuration_2 <= -0.33242902159690857) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.36858421564102173) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07693177089095116) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5931233167648315) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.024488925002515316) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.48469358682632446) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.45206885039806366) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.47563140094280243) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2744697332382202) { - if (maxDuration_2 <= -0.5989924371242523) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (averageDuration_2 <= -0.3656543046236038) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.40201225876808167) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5942909717559814) { - if (averageDuration_2 <= -0.43314817547798157) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (averageDuration_2 <= -0.5060972273349762) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.42785969376564026) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3176281005144119) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5466181039810181) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.5164822936058044) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.09725334867835045) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.842471718788147) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.011714194901287556) { - if (averageDuration_2 <= -0.5017145276069641) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (averageDuration_2 <= -0.43901774287223816) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6961819529533386) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485521733760834) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.4974755644798279) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.03696174267679453) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.42411841452121735) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.24362723529338837) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.29506441950798035) { - if (averageDuration_2 <= -0.4380848854780197) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (averageDuration_2 <= -0.44128017127513885) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7207963466644287) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7471691071987152) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.30674906075000763) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.43663278222084045) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.12104194611310959) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.4108966141939163) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6597457826137543) { - if (averageDuration_2 <= -0.46600283682346344) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2028055191040039) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.27601249516010284) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.7111433446407318) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.405785396695137) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.49180084466934204) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.477101594209671) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.4355500042438507) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.389234334230423) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.46072281897068024) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.47018684446811676) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.45189976692199707) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.019049725495278835) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.11203369870781898) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2854778319597244) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4394821673631668) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5636525750160217) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.734325647354126) { - if (maxDuration_2 <= -0.5053053796291351) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06428303010761738) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485359311103821) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3740568459033966) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4259895086288452) { - if (averageDuration_2 <= -0.5106721222400665) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26141680777072906) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.4689476490020752) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6905945241451263) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3128224015235901) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486049830913544) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (averageDuration_2 <= -0.4547649025917053) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.10743620991706848) { - if (maxDuration_2 <= -0.33012424409389496) { - if (averageDuration_2 <= -0.49963298439979553) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4403581768274307) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7425623834133148) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (maxDuration_2 <= -0.36448031663894653) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.35043902695178986) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (maxDuration_2 <= -0.11821127310395241) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748622864484787) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225883811712265) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.4109240174293518) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.47685542702674866) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.46037299931049347) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0887279137969017) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5697632133960724) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.4549849182367325) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7168501317501068) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3357419818639755) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3712909519672394) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5530483722686768) { - if (maxDuration_2 <= -0.38523824512958527) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5726436972618103) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.4643188714981079) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.456339955329895) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3300284445285797) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.11841470375657082) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.19587627053260803) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5362854897975922) { - if (maxDuration_2 <= -0.41052715480327606) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.03906398080289364) { - if (averageDuration_2 <= -0.40963590145111084) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.3908051401376724) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5523447692394257) { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.4104207903146744) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.3719923794269562) { - if (maxDuration_2 <= -0.38130737841129303) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.49276863038539886) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1857169196009636) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.34520843625068665) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.43344974517822266) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7438471615314484) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0953757762908936) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6379465162754059) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.3294961154460907) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0948266983032227) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7104938924312592) { - if (maxDuration_2 <= -0.4453643262386322) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6514590382575989) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7597685754299164) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.610610157251358) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (averageDuration_2 <= -0.3061417043209076) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2548815459012985) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4000978320837021) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.29631587862968445) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.29435835778713226) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.007171630859375) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3644263595342636) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2360130473971367) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.53001868724823) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2973712980747223) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9434346258640289) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.060656189918518) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4316839426755905) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485944032669067) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7305657267570496) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4427632838487625) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21020342409610748) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (averageDuration_2 <= -0.33378028869628906) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4564969390630722) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (maxDuration_2 <= -0.25433603674173355) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23887929320335388) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9699702560901642) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.4313230663537979) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9475547671318054) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.45885269343852997) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20277021080255508) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6792775392532349) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.12048579379916191) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0735624432563782) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.38062185049057007) { - if (averageDuration_2 <= -0.31052224338054657) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.2258281484246254) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5330982506275177) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484611868858337) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.3201896995306015) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.30082476139068604) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5611414611339569) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9217639267444611) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.842471718788147) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.29752521216869354) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.32565318048000336) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.020805480889976025) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1896788254380226) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.3502329885959625) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.26303599774837494) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6895642578601837) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.15303920209407806) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.10928329825401306) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6546749770641327) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.32107996940612793) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.13277871906757355) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.3334406763315201) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37980569899082184) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.25732724368572235) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9114156365394592) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6553419530391693) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3357419818639755) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (averageDuration_2 <= -0.3304867595434189) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4831969439983368) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8383578360080719) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2888488173484802) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0011512195924296975) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.29162636399269104) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7550370395183563) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (averageDuration_2 <= -0.3473919481039047) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6014033854007721) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4405665844678879) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0034555174643173814) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.22445404529571533) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5546018779277802) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.35571321845054626) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5957482159137726) { - if (averageDuration_2 <= -0.33295397460460663) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09477000683546066) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (maxDuration_2 <= -0.19607143104076385) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.261422798037529) { - if (maxDuration_2 <= -0.44513383507728577) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7814852297306061) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.640639990568161) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (averageDuration_2 <= -0.3160882741212845) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486155331134796) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (maxDuration_2 <= -0.1554674133658409) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (averageDuration_2 <= -0.2909882962703705) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7041383981704712) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07533213868737221) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.30124498903751373) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.060450464487075806) { - if (maxDuration_2 <= -0.37136659026145935) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8414077162742615) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.18656859546899796) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.20904050767421722) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4641064554452896) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6243166923522949) { - if (averageDuration_2 <= -0.2971619814634323) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.026461328379809856) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9270704686641693) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.32033687829971313) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.31018005311489105) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.38068194687366486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8721916675567627) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.026462645269930363) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.16709522902965546) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.2588973939418793) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (maxDuration_2 <= -0.3104604631662369) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300742030143738) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.30370788276195526) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.2924126982688904) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.522097259759903) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06071360036730766) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.35397788882255554) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.31898725032806396) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6958546936511993) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748256504535675) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485944032669067) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486123144626617) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.03280009888112545) { - if (averageDuration_2 <= -0.33573997020721436) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.49064502120018005) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.34419097006320953) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.02211772743612528) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.417383149266243) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7827769219875336) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0761001892387867) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.21714510023593903) { - if (maxDuration_2 <= -0.178725004196167) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (averageDuration_2 <= -0.3312353640794754) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { - if (maxDuration_2 <= -0.3506186902523041) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4309518188238144) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7372922599315643) { - if (maxDuration_2 <= -0.3793648034334183) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9375555515289307) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.02954611461609602) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.029591891914606094) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (averageDuration_2 <= -0.3216385245323181) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.0897640734910965) { - if (maxDuration_2 <= -0.49159595370292664) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.06401299126446247) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.33471575379371643) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.011142936069518328) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1073484979569912) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (maxDuration_2 <= -0.17785881459712982) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4740087240934372) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5872890949249268) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1717079058289528) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6689273118972778) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.055434899404644966) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (maxDuration_2 <= -0.49465303122997284) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (averageDuration_2 <= -0.32559140026569366) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.646384060382843) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6380632519721985) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6697246134281158) { - if (averageDuration_2 <= -0.34251372516155243) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.42763808369636536) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.462016761302948) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.32818686962127686) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.46072521805763245) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.26792269945144653) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4107401967048645) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6580115556716919) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7571949660778046) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (averageDuration_2 <= -0.2955334335565567) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1668855994939804) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8255780041217804) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15925020724534988) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5745860934257507) { - if (maxDuration_2 <= -0.39554373919963837) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06109306775033474) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.267517626285553) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6169191598892212) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.27511419355869293) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6796722710132599) { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.308965727686882) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.12848735973238945) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.32213953137397766) { - if (averageDuration_2 <= -0.3138471096754074) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7774899303913116) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.44896169006824493) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.47041742503643036) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (maxDuration_2 <= -0.3643232136964798) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.29769130051136017) { - if (maxDuration_2 <= -0.3245902508497238) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.3099205642938614) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6199217438697815) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1351606249809265) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6542955935001373) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.26406416296958923) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7266464829444885) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8383578360080719) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5135562717914581) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7541288733482361) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.21551334857940674) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08976732194423676) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.12879037857055664) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3639540523290634) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5702849924564362) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1932036578655243) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - if (maxDuration_2 <= -0.3252209275960922) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4855744391679764) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.31115463376045227) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4212530106306076) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3831788897514343) { - if (maxDuration_2 <= -0.4980189651250839) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.38811175525188446) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485432326793671) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4841309189796448) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.3175671845674515) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7972817122936249) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.5010329633951187) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.32494740188121796) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7551675140857697) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.2579679489135742) { - if (averageDuration_2 <= -0.3078204393386841) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.20732781291007996) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.727687805891037) { - if (averageDuration_2 <= -0.4446764439344406) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7411335706710815) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (averageDuration_2 <= -0.48013298213481903) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.38501784205436707) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5840363502502441) { - if (averageDuration_2 <= -0.5102361440658569) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.14397023618221283) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5800697803497314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4191809296607971) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42589758336544037) { - if (maxDuration_2 <= -0.48572011291980743) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0902109146118164) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.545682430267334) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.030746312346309423) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4856390506029129) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6191723346710205) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7405544221401215) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8067652583122253) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.8165296912193298) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4708937853574753) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - if (averageDuration_2 <= -0.3135262131690979) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225883811712265) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28266243636608124) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.056200893595814705) { - if (maxDuration_2 <= -0.536351203918457) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7699341475963593) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.3981545567512512) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.46658407151699066) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.49416443705558777) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.45945559442043304) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485738694667816) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26713743805885315) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7241617441177368) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2999030500650406) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4944087117910385) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8442182540893555) { - if (averageDuration_2 <= -0.4250757396221161) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.4104030579328537) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.459503173828125) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4907570630311966) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (maxDuration_2 <= -0.6040298044681549) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.10847101360559464) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6918887495994568) { - if (averageDuration_2 <= -0.2892002910375595) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3735290765762329) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5970370173454285) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.5067297518253326) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.44272398948669434) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.46869537234306335) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.45012809336185455) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5800626873970032) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.157261312007904) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26816023886203766) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.3236072510480881) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.07564329728484154) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4020204544067383) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.24450450390577316) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3675512820482254) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (averageDuration_2 <= -0.29318319261074066) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (averageDuration_2 <= -0.30290183424949646) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.32844461500644684) { - if (maxDuration_2 <= -0.23552051186561584) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606539070606) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.05308774672448635) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (averageDuration_2 <= -0.3037213087081909) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4804832637310028) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (maxDuration_2 <= -0.3744261711835861) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5363812297582626) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8383578360080719) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2961706221103668) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.2818055599927902) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8277158737182617) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4904833436012268) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6351950466632843) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.32459279894828796) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5802454054355621) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5212530493736267) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7138456404209137) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (averageDuration_2 <= -0.4826563149690628) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0176811814308167) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5664218962192535) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.7367621660232544) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.3452174961566925) { - if (averageDuration_2 <= -0.4808720201253891) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8575237095355988) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (maxDuration_2 <= -0.36384451389312744) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5294224619865417) { - if (averageDuration_2 <= -0.3788570910692215) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4290819764137268) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6521439552307129) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3031439334154129) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6052127778530121) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.4961499273777008) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.39636632800102234) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5425024926662445) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5810853540897369) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485911548137665) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.3469972759485245) { - if (maxDuration_2 <= -0.24029217660427094) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4592728316783905) { - if (averageDuration_2 <= -0.5005058348178864) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8092304468154907) { - if (maxDuration_2 <= -0.527317076921463) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7166167199611664) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.3805789053440094) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6507578194141388) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1201142780482769) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.35893769562244415) { - if (maxDuration_2 <= -0.594104140996933) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.2328837439417839) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.194828562438488) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.91253662109375) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4518558830022812) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.17103000730276108) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20013290643692017) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.03208610601723194) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - if (maxDuration_2 <= -0.3199402987957001) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.45828890800476074) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (numDurations_2 <= 1.0085371732711792) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.11844425648450851) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27587294578552246) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.09959760308265686) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (averageDuration_2 <= -0.3067745715379715) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.267594538629055) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.3165307939052582) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4616197943687439) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3550025224685669) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.1510351076722145) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.38419879972934723) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.338320329785347) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4088563770055771) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744978427887) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5143053084611893) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6156865954399109) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4463558793067932) { - if (maxDuration_2 <= -0.27000077068805695) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4716603457927704) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.48630382120609283) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4204797148704529) { - if (averageDuration_2 <= -0.3731165826320648) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.31107212603092194) { - if (maxDuration_2 <= -0.3498057425022125) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6655000150203705) { - if (averageDuration_2 <= -0.36327970027923584) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (numDurations_2 <= 1.008537232875824) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936677023768425) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.03568781167268753) { - if (averageDuration_2 <= -0.48907576501369476) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486096024513245) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9567630290985107) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6882989406585693) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118889793754) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.18798432499170303) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5082663297653198) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (averageDuration_2 <= -0.4896525889635086) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.535529226064682) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.405038520693779) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.5193292051553726) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.06424967106431723) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7282001078128815) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5797421634197235) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07364777103066444) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.7789206802845001) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.393616259098053) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748550534248352) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.35311898589134216) { - if (averageDuration_2 <= -0.3177209049463272) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597728431224823) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8015496134757996) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4485579580068588) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.3585778623819351) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.26351524889469147) { - if (averageDuration_2 <= -0.3358721137046814) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4646168649196625) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.44904083013534546) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (averageDuration_2 <= -0.48851965367794037) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7481491267681122) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1491454839706421) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3289659768342972) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.29460790753364563) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5138256549835205) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (averageDuration_2 <= -0.3546811640262604) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2024102360010147) { - if (averageDuration_2 <= -0.36064085364341736) { - if (averageDuration_2 <= -0.36549951136112213) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.25586676597595215) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7963813841342926) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.41663283109664917) { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.4326551556587219) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7583918869495392) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.43871140480041504) { - if (maxDuration_2 <= -0.43243739008903503) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.022922703996300697) { - if (averageDuration_2 <= -0.4344189763069153) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.41698041558265686) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.661494642496109) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5528627932071686) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744438856840134) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6463684141635895) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.22502101957798004) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5253871083259583) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8002188205718994) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6037119626998901) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8733290135860443) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.4058011472225189) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.08079643547534943) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8041815161705017) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.4528794288635254) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7382297813892365) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.03130711615085602) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.40464988350868225) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.4296058267354965) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (averageDuration_2 <= -0.3516629785299301) { - if (maxDuration_2 <= -0.35057583451271057) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.19273536652326584) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.12834439426660538) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.48990415036678314) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8676228225231171) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.671675831079483) { - if (averageDuration_2 <= -0.3513958752155304) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.4221218228340149) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.031407841481268406) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3159213364124298) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.39286914467811584) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.41435506939888) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.503915011882782) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.49696534872055054) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.016497523058205843) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.39258554577827454) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6679727137088776) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.08481725305318832) { - if (averageDuration_2 <= -0.36943840980529785) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6755871176719666) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.06551247090101242) { - if (averageDuration_2 <= -0.4933241456747055) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0739621818065643) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8722561299800873) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8938936293125153) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.34456442296504974) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8541332185268402) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.45699694752693176) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.46248646080493927) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6546749770641327) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6582233607769012) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.015414451248943806) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5140326619148254) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.41264815628528595) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (averageDuration_2 <= -0.4358626455068588) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18886860460042953) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.4593397378921509) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2171775922179222) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.02553339023143053) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.47780922055244446) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (maxDuration_2 <= -0.4877311885356903) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.47117750346660614) { - if (numDurations_2 <= 3.8542970418930054) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746412754059) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6400006711483002) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620310544968) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.14982610195875168) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7159679532051086) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2705480009317398) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.32305124402046204) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.09423814341425896) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.591503232717514) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.7789206802845001) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.08014403656125069) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.05986323952674866) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6973955929279327) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14222664386034012) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.35748493671417236) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5794715285301208) { - if (maxDuration_2 <= -0.3650399148464203) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.415433794260025) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6254217326641083) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (maxDuration_2 <= -0.4546845853328705) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.0022142911329865456) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7573903799057007) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6550918221473694) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.41428808867931366) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.31242114305496216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5713098049163818) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4011714905500412) { - if (averageDuration_2 <= -0.32468704879283905) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3699488788843155) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7611453235149384) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.45118187367916107) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (averageDuration_2 <= -0.3809977173805237) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (maxDuration_2 <= -0.47351764142513275) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.47201691567897797) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5223143696784973) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1201142780482769) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0726829431951046) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.40178413689136505) { - if (averageDuration_2 <= -0.47677844762802124) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3474990874528885) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.40035396814346313) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5768094062805176) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.42250923812389374) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - if (maxDuration_2 <= -0.4103929400444031) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4224357008934021) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7363114655017853) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6289030909538269) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6421366930007935) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7592478096485138) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.39341557025909424) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (averageDuration_2 <= -0.36643627285957336) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.37846361100673676) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.08858950808644295) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6898222863674164) { - if (averageDuration_2 <= -0.45684851706027985) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485513687133789) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (maxDuration_2 <= -0.3479366600513458) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (maxDuration_2 <= -0.3493625819683075) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7594334483146667) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6288082599639893) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.3393559604883194) { - if (maxDuration_2 <= -0.26309654116630554) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.956356555223465) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.24452946335077286) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5987571775913239) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.36372239887714386) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.3910958617925644) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.035508258268237114) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (averageDuration_2 <= -0.4474133104085922) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.34249405562877655) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (maxDuration_2 <= -0.23154182732105255) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.750958263874054) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.613947868347168) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.41320350766181946) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6941463351249695) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4268268644809723) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.4434513449668884) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3813876509666443) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.48559823632240295) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2206752896308899) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7655411958694458) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7890982329845428) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (averageDuration_2 <= -0.4064783304929733) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5707090497016907) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.38829703629016876) { - if (maxDuration_2 <= -0.0679171122610569) { - if (averageDuration_2 <= -0.38002586364746094) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.4085203856229782) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.410805806517601) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5805707275867462) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (maxDuration_2 <= -0.31491290032863617) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.16563347727060318) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05890175327658653) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.141227625310421) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6094601452350616) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8534824848175049) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.2893225997686386) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7363114953041077) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8651732802391052) { - if (averageDuration_2 <= -0.31018516421318054) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - if (averageDuration_2 <= -0.3054914027452469) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.30377237498760223) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.29039858281612396) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5932562053203583) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.363677442073822) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.040665093809366226) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5607988238334656) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486057877540588) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7378681898117065) { - if (numDurations_2 <= 1.5776892304420471) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.047890182584524155) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5675286054611206) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818998217583) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.4027012437582016) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.598081111907959) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.20690107345581055) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (maxDuration_2 <= -0.3708348423242569) { - if (maxDuration_2 <= -0.4281648248434067) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.2852247506380081) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.20141274482011795) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.07486025243997574) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (averageDuration_2 <= -0.29829278588294983) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.0767739973962307) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (maxDuration_2 <= -0.3830752968788147) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (maxDuration_2 <= -0.3557474911212921) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2007257044315338) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.01605401560664177) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7981161177158356) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6879471838474274) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.11507272720336914) { - if (averageDuration_2 <= -0.30687759816646576) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.30310551822185516) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.18022698909044266) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.685827910900116) { - if (numDurations_2 <= 1.008537232875824) { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.4201842397451401) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.39995812624692917) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6126697659492493) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0534384846687317) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.45547060668468475) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731648460030556) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.3718687891960144) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.747517317533493) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281765937805) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8987214267253876) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.49880214035511017) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8261427581310272) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2961706221103668) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.744253933429718) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.04984685266390443) { - if (averageDuration_2 <= -0.4495915174484253) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.2664978951215744) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7474215030670166) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9171100854873657) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.07610019110143185) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.5816256105899811) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748624712228775) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4070816785097122) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.074907898902893) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5887058973312378) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485283613204956) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.29847927391529083) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7459770739078522) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7099223434925079) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4479955583810806) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5089184045791626) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (averageDuration_2 <= -0.5104620456695557) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7104181349277496) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.47217778861522675) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4708722084760666) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.33538465201854706) { - if (averageDuration_2 <= -0.3478458821773529) { - if (averageDuration_2 <= -0.35028646886348724) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.17337136715650558) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.07018454372882843) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.21545716375112534) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.2976195961236954) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.05420057661831379) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.536476343870163) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.11005362495779991) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.668930321931839) { - if (maxDuration_2 <= -0.4943845868110657) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6457469165325165) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.4950197637081146) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (averageDuration_2 <= -0.47629252076148987) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (averageDuration_2 <= -0.4891490191221237) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5077300071716309) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7458292543888092) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486039102077484) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5286239683628082) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.4606615751981735) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17025545984506607) { - if (maxDuration_2 <= -0.42046791315078735) { - if (averageDuration_2 <= -0.46668004989624023) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7401580214500427) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - if (averageDuration_2 <= -0.3470374047756195) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1862863078713417) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.19960515201091766) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6749989092350006) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485586702823639) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - if (averageDuration_2 <= -0.43673139810562134) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4366367906332016) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.44459065794944763) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.0620607640594244) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.43314145505428314) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.39739227294921875) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.46866774559020996) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8093487322330475) { - if (averageDuration_2 <= -0.36962103843688965) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9917370676994324) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (averageDuration_2 <= -0.4076513946056366) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.025448912754654884) { - if (maxDuration_2 <= -0.17032655328512192) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6561910510063171) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.40391460061073303) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (numDurations_2 <= 0.43938523530960083) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4478093683719635) { - if (maxDuration_2 <= -0.41773512959480286) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.983519434928894) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606539070606) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2751520872116089) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.700155109167099) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - if (maxDuration_2 <= -0.5333474576473236) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.9961256682872772) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7020585536956787) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.5797589719295502) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5932983756065369) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.47584012150764465) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.532177746295929) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.014044463634491) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4362926781177521) { - if (numDurations_2 <= -0.6989187151193619) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0844725370407104) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5361006259918213) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6903150081634521) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.71750608086586) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (maxDuration_2 <= -0.49790501594543457) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.8366779685020447) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5719051659107208) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7205657064914703) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.8463466763496399) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.2734594941139221) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5107482671737671) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.017642080783844) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5906648337841034) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.307508111000061) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.5261394381523132) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - if (numDurations_2 <= -1.837222695350647) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485391795635223) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7677943408489227) { - if (maxDuration_2 <= -0.6094803214073181) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6071829497814178) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5546368062496185) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3319229334592819) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7482790648937225) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7963813841342926) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= -1.837222695350647) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.55804842710495) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.6158093214035034) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5280240774154663) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6501077115535736) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5339852571487427) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.725471168756485) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484636604785919) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7447826862335205) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { - if (maxDuration_2 <= -0.42687322199344635) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.46997955441474915) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486179769039154) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.4796290397644043) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.720297634601593) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9318718314170837) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - if (maxDuration_2 <= -0.4857430160045624) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0699530839920044) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.5945347547531128) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0515487790107727) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.268506944179535) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.4681534916162491) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (maxDuration_2 <= -0.5439392328262329) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484530508518219) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (maxDuration_2 <= -0.553269624710083) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8808378577232361) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8416959345340729) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6176401376724243) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6269329786300659) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6778150796890259) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0811641216278076) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2961706221103668) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6637381911277771) { - if (maxDuration_2 <= -0.22174032777547836) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7340626120567322) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2355353236198425) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1447301506996155) { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.17676475644111633) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7272540330886841) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= -0.6989187151193619) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6461068987846375) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9903765916824341) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.376254677772522) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.550200343132019) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0005265474319458) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (maxDuration_2 <= -0.3297569453716278) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { - if (averageDuration_2 <= -0.35993652045726776) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.517245888710022) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.054501403123140335) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4440595507621765) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6324072480201721) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7400908172130585) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { - if (maxDuration_2 <= -0.5807366669178009) { - if (averageDuration_2 <= -0.45982521772384644) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.10027653723955154) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.28394149243831635) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9010830223560333) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.20529384911060333) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (maxDuration_2 <= -0.4650661200284958) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9882445931434631) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6036377549171448) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9968165457248688) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.41473640501499176) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9626342952251434) { - if (maxDuration_2 <= -0.5730423629283905) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.457562193274498) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4953170716762543) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.37824735045433044) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0022378471912816167) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2039308324456215) { - if (maxDuration_2 <= -0.6604886054992676) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.26050466299057) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.1083666682243347) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6911803781986237) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.4094298779964447) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6810666024684906) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8175210058689117) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (maxDuration_2 <= -0.521448940038681) { - if (averageDuration_2 <= -0.47019432485103607) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9232408702373505) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485074996948242) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.5132758915424347) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - if (maxDuration_2 <= -0.5472696721553802) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (maxDuration_2 <= -0.49114011228084564) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.768743097782135) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.4933537095785141) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748610109090805) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748584657907486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.470766082406044) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.05089460453018546) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.44873304665088654) { - if (maxDuration_2 <= -0.5478827357292175) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5930216312408447) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.31374046206474304) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485454380512238) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5447825193405151) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5110073238611221) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.2343200072646141) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5400852262973785) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485944032669067) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5915840268135071) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4328085631132126) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.18011285364627838) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5556620061397552) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7279088795185089) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344535857439041) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2829601541161537) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.4827240854501724) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486019730567932) { - if (averageDuration_2 <= -0.4649517387151718) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835330963135) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (averageDuration_2 <= -0.4306986629962921) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7691725492477417) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.393446609377861) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6825165748596191) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.4511617422103882) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9387838244438171) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.46083788573741913) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.41775383055210114) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.23199841380119324) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6355882883071899) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.738009512424469) { - if (maxDuration_2 <= -0.12319058552384377) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485676109790802) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5050598084926605) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7471512258052826) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7686004638671875) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5487850606441498) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7482526898384094) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291473031044006) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7581554055213928) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.548366367816925) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4051479399204254) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - if (maxDuration_2 <= -0.23811417073011398) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6978890001773834) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8877497613430023) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9713059067726135) { - if (maxDuration_2 <= -0.2406822219491005) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7620782852172852) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 1.008537232875824) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27359987050294876) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6413657963275909) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040612459183) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.36921538412570953) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (maxDuration_2 <= -0.5795513987541199) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.2364568710327148) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5925949513912201) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.4855809062719345) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.046594943618401885) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.25455667078495026) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.4768766462802887) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484920620918274) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.545476496219635) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.13044001534581184) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.283537894487381) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (averageDuration_2 <= -0.49570733308792114) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485251128673553) { - if (averageDuration_2 <= -0.5029206275939941) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.0545014007948339) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (maxDuration_2 <= -0.27935898303985596) { - if (numDurations_2 <= 2.7159931659698486) { - if (averageDuration_2 <= -0.42652927339076996) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4236503690481186) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4624898433685303) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (maxDuration_2 <= -0.41106657683849335) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.3213493227958679) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4475400298833847) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.10933853313326836) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5977640151977539) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6563952267169952) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.5361257493495941) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (averageDuration_2 <= -0.4961100220680237) { - if (maxDuration_2 <= -0.5019244104623795) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9074200093746185) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8432371318340302) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8474216461181641) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7483058273792267) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6139182448387146) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (numDurations_2 <= 1.008537232875824) { - if (maxDuration_2 <= -0.3855877071619034) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6897099614143372) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (averageDuration_2 <= -0.45100052654743195) { - if (maxDuration_2 <= -0.4476033002138138) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.591844379901886) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0386288166046143) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6631421148777008) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.33925747871398926) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.743899405002594) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.47409768402576447) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.42708034813404083) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.4764971286058426) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7292035222053528) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.49841733276844025) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.39925357699394226) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1063312888145447) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 1.5776891708374023) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.34024015069007874) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.530580997467041) { - if (averageDuration_2 <= -0.2467171847820282) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48052878677845) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6542955935001373) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7253695428371429) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.791291207075119) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.19144360721111298) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.098836600780487) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6207029223442078) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - if (maxDuration_2 <= -0.3710094690322876) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7617442607879639) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0712340474128723) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.26744791865348816) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.722954273223877) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - if (averageDuration_2 <= -0.2634769082069397) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5335469245910645) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6790743172168732) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.351614311337471) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748550534248352) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7445378601551056) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.2609957754611969) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7529622316360474) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6401868760585785) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.40303030610084534) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0384001731872559) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3895476758480072) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8314102292060852) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8928012549877167) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9385550916194916) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.453456997871399) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3598385751247406) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (averageDuration_2 <= -0.2657439857721329) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4148102104663849) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (averageDuration_2 <= -0.25159791111946106) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9757379591464996) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.1912466585636139) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.2597963809967041) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7464922070503235) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.4374699890613556) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8029898405075073) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4424275755882263) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6259874701499939) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5219020843505859) { - if (numDurations_2 <= 2.4314171075820923) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.109816074371338) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935025334358215) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.115248680114746) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.16213075816631317) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (averageDuration_2 <= -0.2707052528858185) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.05452299118042) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5477696657180786) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485018074512482) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.4159293621778488) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8599216341972351) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.40187491476535797) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9961101114749908) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.13310105353593826) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (averageDuration_2 <= -0.2716637849807739) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.2826836556196213) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.2597251534461975) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - if (maxDuration_2 <= -0.35999220609664917) { - if (averageDuration_2 <= -0.28293679654598236) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.749390035867691) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7209117412567139) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486073970794678) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.2609967738389969) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3711787015199661) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (maxDuration_2 <= -0.3931199461221695) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7385323941707611) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7799805104732513) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.4960829168558121) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746412754059) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8237166702747345) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5833738744258881) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4031534194946289) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.39633896946907043) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.43883752822875977) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9569809138774872) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7064080834388733) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6675347983837128) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (averageDuration_2 <= -0.27070485055446625) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0290856957435608) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.010598020628094673) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7026547789573669) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4042154997587204) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.038097321987152) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0761001892387867) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (averageDuration_2 <= -0.25044088810682297) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.29162636399269104) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6364509463310242) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5418795943260193) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.783620148897171) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.14856670703738928) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= -0.6989187151193619) { - if (maxDuration_2 <= -0.2421409860253334) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.10004199296236038) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.36047783493995667) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (maxDuration_2 <= -0.2743011564016342) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4275834560394287) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 1.008537232875824) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - if (maxDuration_2 <= -0.28578707575798035) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.004179835319519) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4926910102367401) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.52086141705513) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.36311502754688263) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5401000678539276) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7429961562156677) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2894272208213806) { - if (maxDuration_2 <= -0.12396308034658432) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3363359570503235) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3206831216812134) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.1578606739640236) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.19574294239282608) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2731478065252304) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821968436241) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.09474093466997147) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 0.1773199513554573) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7048766911029816) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (averageDuration_2 <= 0.2523887902498245) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3437920808792114) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.05343278683722019) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.044003456830978394) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7935460805892944) { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.11785173416137695) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485982179641724) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 0.3530064821243286) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= 0.24603942781686783) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.00288325548172) { - if (numDurations_2 <= -1.837222695350647) { - if (maxDuration_2 <= -0.2317165806889534) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1007722616195679) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.581272691488266) { - if (maxDuration_2 <= -0.40268075466156006) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7466290593147278) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5992238819599152) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4337121397256851) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1738765835762024) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2296112775802612) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (averageDuration_2 <= 0.2111334353685379) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.0423296093940735) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5832706987857819) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= 0.23321307450532913) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.2259503602981567) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.1896548569202423) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.123512864112854) { - if (averageDuration_2 <= -0.2448047697544098) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.15357730910182) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0744428038597107) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (averageDuration_2 <= -0.23738114535808563) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400544703006744) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5934512615203857) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0618970394134521) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.1681392565369606) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.277814045548439) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5902966260910034) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6079044044017792) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (numDurations_2 <= 1.008537232875824) { - if (numDurations_2 <= -1.2680706679821014) { - if (averageDuration_2 <= -0.016837602481245995) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7554211020469666) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7052259147167206) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - if (averageDuration_2 <= -0.1689627692103386) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.25149397924542427) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795464992523) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7073500752449036) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.170151710510254) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.1416710466146469) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5897138118743896) { - if (averageDuration_2 <= -0.22400811314582825) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.49333690106868744) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3722195252776146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.3244738429784775) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7122727334499359) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486204206943512) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (averageDuration_2 <= -0.23641596734523773) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.24511196464300156) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6946292519569397) { - if (averageDuration_2 <= -0.10026612132787704) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (maxDuration_2 <= -0.045685144141316414) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { - if (averageDuration_2 <= 0.042987169697880745) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.04388689622282982) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748530238866806) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.0830427035689354) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.20511864125728607) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (averageDuration_2 <= -0.2357349395751953) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486163675785065) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.637305736541748) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5884650349617004) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.24472576379776) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - if (averageDuration_2 <= 0.28353404998779297) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484538853168488) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 0.31062352657318115) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.3351248651742935) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 0.3080146461725235) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1710380911827087) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.23255515843629837) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5572963654994965) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (maxDuration_2 <= -0.3823610842227936) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2602965235710144) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7725189626216888) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281765937805) { - if (averageDuration_2 <= -0.24076326191425323) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5701518654823303) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.34018470346927643) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.23569945245981216) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6509048640727997) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.115165650844574) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6834496855735779) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6501388847827911) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6652964651584625) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (maxDuration_2 <= -0.07779719308018684) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.470812126994133) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.64189013838768) { - if (averageDuration_2 <= -0.24108047783374786) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7089749872684479) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.1797604337334633) { - if (maxDuration_2 <= -0.367205411195755) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0694704055786133) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.14383991807699203) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.2145853489637375) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.18983230739831924) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9326036870479584) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.07104289624840021) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6219784617424011) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.18786301463842392) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.1516360640525818) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0356164574623108) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6830730140209198) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5880368947982788) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.109580636024475) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.1805582195520401) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (averageDuration_2 <= -0.24189448356628418) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6661689579486847) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5931340754032135) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (averageDuration_2 <= -0.18173972517251968) { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.613742470741272) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.2531558722257614) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7334689199924469) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7094421684741974) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.11199888586997986) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= 0.007401691924314946) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0545474290847778) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.3639002740383148) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6792885661125183) { - if (averageDuration_2 <= -0.09441689029335976) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6783876717090607) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.2569674402475357) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (numDurations_2 <= 0.43938523530960083) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6838200092315674) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6971320509910583) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.16740044206380844) { - if (maxDuration_2 <= -0.2488374337553978) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7991330921649933) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9228914678096771) { - if (maxDuration_2 <= -0.08214079961180687) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1358182430267334) { - if (maxDuration_2 <= -0.24255893379449844) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2677497267723083) { - if (numDurations_2 <= -1.2680706679821014) { - if (maxDuration_2 <= -0.11115770787000656) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3345186114311218) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2490962147712708) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6850359439849854) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.1602861285209656) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6515218913555145) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1457267999649048) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.045991696417331696) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.1513097882270813) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9731535613536835) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (maxDuration_2 <= -0.15360576659440994) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.4502701163291931) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6837252676486969) { - if (numDurations_2 <= -1.837222695350647) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.281745433807373) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7160948514938354) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1793452501296997) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7346994578838348) { - if (averageDuration_2 <= 0.24847883731126785) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2100608348846436) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6315911114215851) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (numDurations_2 <= 3.0005691051483154) { - if (maxDuration_2 <= -0.3665924519300461) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6648445129394531) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6322458684444427) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6054599583148956) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4165748506784439) { - if (averageDuration_2 <= -0.21011117845773697) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0478700399398804) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.018933151848614216) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.11995896697044373) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0920674204826355) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7166780829429626) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4848266690969467) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485277950763702) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (maxDuration_2 <= -0.3053671419620514) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6464059054851532) { - if (averageDuration_2 <= -0.24128907918930054) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.2154373973608017) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5004319697618484) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.0508946068584919) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.23024196922779083) { - if (averageDuration_2 <= -0.23238848894834518) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (averageDuration_2 <= -0.22913186252117157) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485716640949249) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4461263567209244) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.3610256314277649) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.863446444272995) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485158741474152) { - if (maxDuration_2 <= -0.29454754292964935) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.42696937918663025) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5130490958690643) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - if (averageDuration_2 <= -0.21454039961099625) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8786736130714417) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42148226499557495) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (averageDuration_2 <= -0.21205616742372513) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.03393502160906792) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (numDurations_2 <= -1.837222695350647) { - if (maxDuration_2 <= -0.17711921781301498) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7401401400566101) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2260653972625732) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.2424069568514824) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (maxDuration_2 <= -0.31782539188861847) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2475817799568176) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.259020447731018) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5305721759796143) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6787751913070679) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748605489730835) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.240234136581421) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748614490032196) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= 0.20604375004768372) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2261719107627869) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8935829401016235) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5651461780071259) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.17223966866731644) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.08208004757761955) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7552095353603363) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.47838354110717773) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.645479142665863) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7334306538105011) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.846452385187149) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7178981602191925) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0147919654846191) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.532191127538681) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (averageDuration_2 <= -0.19586879760026932) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (averageDuration_2 <= -0.18694283068180084) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.0856764130294323) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (averageDuration_2 <= -0.15411896258592606) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.95707568526268) { - if (averageDuration_2 <= -0.20437650382518768) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.06648130714893341) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7999384105205536) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.029591891914606094) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0914928913116455) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.3959844261407852) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6892985105514526) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0374455451965332) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.2972804009914398) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.39799924194812775) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9603586792945862) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.23355037719011307) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5792979001998901) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089094400406) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485944032669067) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - if (averageDuration_2 <= -0.20765072852373123) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.35780930519104004) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.19434059411287308) { - if (maxDuration_2 <= -0.29422593116760254) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485781610012054) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.10905060917139053) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7849734127521515) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9803360998630524) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.1951431855559349) { - if (maxDuration_2 <= -0.2538851946592331) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.36205220222473145) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.05066198669373989) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9110424220561981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.3149256706237793) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3955477625131607) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (maxDuration_2 <= -0.3805374950170517) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5595024228096008) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { - if (averageDuration_2 <= -0.2384049966931343) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (maxDuration_2 <= -0.2808178663253784) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9346790015697479) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= 0.16313345730304718) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (averageDuration_2 <= -0.20082448422908783) { - if (maxDuration_2 <= -0.23878026008605957) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.852187842130661) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - if (maxDuration_2 <= -0.38226477801799774) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7124348282814026) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.344644159078598) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6733290553092957) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.36745911836624146) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484953105449677) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.10438440088182688) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9074200093746185) { - if (maxDuration_2 <= -0.09280852600932121) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.2951493263244629) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748590350151062) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.38419879972934723) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.25467295944690704) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3441336750984192) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485979199409485) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.2242875173687935) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4740087240934372) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (averageDuration_2 <= -0.15035947412252426) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1258509755134583) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.5068358182907104) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4633892774581909) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (averageDuration_2 <= -0.17466029524803162) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.24042631685733795) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (maxDuration_2 <= -0.388084813952446) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748583048582077) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.11044968664646149) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (maxDuration_2 <= -0.30533936619758606) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.43761681020259857) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.20778769254684448) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= 0.004477373324334621) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.2327411249279976) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3190268576145172) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5364265739917755) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5143053084611893) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7016863524913788) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.0642496682703495) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6888016164302826) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0586062669754028) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8405185639858246) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592867255211) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (maxDuration_2 <= -0.22685886174440384) { - if (averageDuration_2 <= -0.2565150111913681) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8636920154094696) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4177165925502777) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5425611734390259) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5903356969356537) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.43803970515727997) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7497720420360565) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.3441503643989563) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9727285504341125) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7965058982372284) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3638896942138672) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5230170786380768) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.3396598547697067) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.2841406613588333) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.44349202513694763) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5143890678882599) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.41048693656921387) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3521897941827774) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8379283249378204) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (numDurations_2 <= -1.837222695350647) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8573937714099884) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (averageDuration_2 <= -0.25020357221364975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7402394711971283) { - if (maxDuration_2 <= -0.07524671778082848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5153296291828156) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7294360399246216) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3208869844675064) { - if (maxDuration_2 <= -0.07633834704756737) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.13060642033815384) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6227197349071503) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8584021031856537) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.29660533368587494) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0021444342855829746) { - if (maxDuration_2 <= -0.08181406930088997) { - if (averageDuration_2 <= -0.28037771582603455) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.27776841819286346) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3900254964828491) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4734959751367569) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2499322071671486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5223480463027954) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0514491200447083) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7732266187667847) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.35476985573768616) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3482970595359802) { - if (averageDuration_2 <= -0.17909052968025208) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5458474159240723) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.13044001534581184) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (maxDuration_2 <= -0.16531187295913696) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.20608334243297577) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.00955027062445879) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9963940978050232) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.21905796229839325) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7418599128723145) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3977990746498108) { - if (averageDuration_2 <= -0.09912717342376709) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5210371166467667) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (maxDuration_2 <= -0.3924412131309509) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.2610907703638077) { - if (maxDuration_2 <= -0.3326544165611267) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.0794384814798832) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.17543501406908035) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.473084956407547) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.07511918991804123) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4585839807987213) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.16147752851247787) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7907251119613647) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6542955935001373) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (maxDuration_2 <= -0.17823107540607452) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.13277871906757355) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (averageDuration_2 <= -0.2055349498987198) { - if (maxDuration_2 <= -0.42188870906829834) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (maxDuration_2 <= -0.13281997293233871) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.36053191125392914) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.1616956666111946) { - if (maxDuration_2 <= -0.3366231620311737) { - if (maxDuration_2 <= -0.3409692794084549) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5080351829528809) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.07112113386392593) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7790552079677582) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.44822995364665985) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.27307097613811493) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (maxDuration_2 <= -0.2883070856332779) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.42694225907325745) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (numDurations_2 <= 1.5776891708374023) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6117027699947357) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5946778655052185) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17447641491889954) { - if (averageDuration_2 <= -0.2530211955308914) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.265903502702713) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3353832811117172) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.3418937623500824) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486106753349304) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4365191012620926) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7388883531093597) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0021231174468994) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.278314009308815) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6946036219596863) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539397239685) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6736651360988617) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7322461307048798) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (maxDuration_2 <= -0.29658880829811096) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485822141170502) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7337377071380615) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9118562936782837) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.2777053862810135) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.31528282165527344) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (maxDuration_2 <= -0.272173747420311) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (averageDuration_2 <= -0.2698711007833481) { - if (maxDuration_2 <= -0.4187912940979004) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8524399399757385) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.21397068351507187) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.010948121547699) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.25677254796028137) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9515121877193451) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8703606426715851) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.3654603660106659) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7448217272758484) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5659129619598389) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.26694755256175995) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2661726027727127) { - if (averageDuration_2 <= -0.27756930887699127) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6623232364654541) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26207540184259415) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.3952498137950897) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485660016536713) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7838986217975616) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.20078985393047333) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4544541537761688) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.2885500639677048) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486041486263275) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.736938089132309) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2398325353860855) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (averageDuration_2 <= -0.25714699923992157) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.35311898589134216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6590187251567841) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225075244904) { - if (maxDuration_2 <= -0.39672403037548065) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - if (maxDuration_2 <= -0.3810085505247116) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.23948934674263) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (averageDuration_2 <= -0.279513880610466) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8412894904613495) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28334183990955353) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5401448309421539) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.281432643532753) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9125480949878693) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.591004490852356) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485692501068115) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.2824273854494095) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.4869600981473923) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5997771620750427) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.2685035169124603) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.14703184366226196) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7771967947483063) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9353727400302887) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5170929729938507) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485326826572418) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2021339312195778) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (averageDuration_2 <= -0.2610175311565399) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (averageDuration_2 <= -0.2662581354379654) { - if (maxDuration_2 <= -0.43308326601982117) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6385996639728546) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (averageDuration_2 <= -0.2782544940710068) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8268061876296997) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5740959346294403) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.657424122095108) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8571807742118835) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.202456533908844) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (maxDuration_2 <= -0.40260232985019684) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7548597455024719) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.28280772268772125) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.04984685266390443) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - if (averageDuration_2 <= -0.26394499838352203) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8008675873279572) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7609889507293701) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2905624657869339) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.42697474360466003) { - if (averageDuration_2 <= -0.26357387006282806) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2138858437538147) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899798870087) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.32735608518123627) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7936733365058899) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6941463351249695) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.35733550786972046) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4129611998796463) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (averageDuration_2 <= -0.22882618010044098) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485603094100952) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4969044327735901) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (maxDuration_2 <= -0.26188093423843384) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995391011238) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.4652613401412964) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2781311571598053) { - if (maxDuration_2 <= -0.18095634877681732) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6264518201351166) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - if (maxDuration_2 <= -0.36662550270557404) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - if (maxDuration_2 <= -0.419176310300827) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3224613815546036) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.22998777776956558) { - if (maxDuration_2 <= -0.1473424807190895) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7385323941707611) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.25681714713573456) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484798729419708) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1578196287155151) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27534817159175873) { - if (averageDuration_2 <= -0.22778252512216568) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1896490901708603) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.639798104763031) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6787176728248596) { - if (maxDuration_2 <= -0.19379205256700516) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26610569655895233) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3285878300666809) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089094400406) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.03564050234854221) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.4995386600494385) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.4995386600494385) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26646843552589417) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6900342404842377) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (maxDuration_2 <= -0.14748673141002655) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038346767426) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (maxDuration_2 <= -0.30952081084251404) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3353877514600754) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (maxDuration_2 <= -0.0537569560110569) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485448718070984) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.20815537124872208) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2514399588108063) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28584088385105133) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (maxDuration_2 <= -0.3631049543619156) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (averageDuration_2 <= -0.18558041751384735) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5758938193321228) { - if (numDurations_2 <= -1.2680706679821014) { - if (maxDuration_2 <= -0.3412022739648819) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7458773255348206) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.913247674703598) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (averageDuration_2 <= -0.18869300186634064) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23939962685108185) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.967848002910614) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9231318235397339) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991199404001) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9291076958179474) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.10518838092684746) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485543489456177) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3198850303888321) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665165930986404) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.2728373259305954) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014949262142181) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (maxDuration_2 <= -0.19027145206928253) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7140167355537415) { - if (averageDuration_2 <= -0.234145388007164) { - if (maxDuration_2 <= -0.35643628239631653) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3192680776119232) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486122846603394) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.24831096082925797) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22427897155284882) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7833621799945831) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6227197349071503) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.42821288108825684) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20315079391002655) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.3387858867645264) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.1988108903169632) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.20016694068908691) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6616968810558319) { - if (maxDuration_2 <= -0.08582834154367447) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.39954543113708496) { - if (maxDuration_2 <= -0.40026476979255676) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.209187850356102) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.45689286291599274) { - if (averageDuration_2 <= -0.22807643562555313) { - if (maxDuration_2 <= -0.21375722438097) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.23909815400838852) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5295973122119904) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.82614666223526) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4479955583810806) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (averageDuration_2 <= -0.23049189150333405) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.41212454438209534) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.27913711965084076) { - if (maxDuration_2 <= -0.11588393896818161) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0322797298431396) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.19132478535175323) { - if (averageDuration_2 <= -0.19212351739406586) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - if (maxDuration_2 <= -0.1207871362566948) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.35733549296855927) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744439005851746) { - if (averageDuration_2 <= 0.23367444425821304) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.1931182742118835) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.0545014007948339) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.599594235420227) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (averageDuration_2 <= 0.10792051628232002) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8599216341972351) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.74852454662323) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7218490242958069) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - if (averageDuration_2 <= -0.17093124240636826) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6449516415596008) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7420169711112976) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.739361971616745) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8147646188735962) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748597651720047) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7922976016998291) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.28193628787994385) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.418925404548645) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0682660341262817) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.2659737467765808) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9349691867828369) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6781851649284363) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8286791443824768) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6021405160427094) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9738000631332397) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.16347970813512802) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.48216956853866577) { - if (maxDuration_2 <= -0.11287758499383926) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7521025836467743) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.04728280380368233) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.2814740240573883) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.29162634164094925) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7098142802715302) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (maxDuration_2 <= -0.28511838614940643) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0803013602271676) { - if (maxDuration_2 <= -0.07321551814675331) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.2110331952571869) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - if (averageDuration_2 <= -0.2074688822031021) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.2822565287351608) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - if (maxDuration_2 <= -0.44082584977149963) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7448217272758484) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7424038648605347) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6498822271823883) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.26150213181972504) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6316382884979248) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.4354717582464218) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - if (maxDuration_2 <= -0.34794169664382935) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.26624464988708496) { - if (maxDuration_2 <= -0.2999219745397568) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.40310265123844147) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.045973898842930794) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.2592342346906662) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.030857334844768047) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999137312173843) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.3813024312257767) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0369514599442482) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8100941777229309) { - if (averageDuration_2 <= -0.2761097103357315) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.5074199438095093) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8097307085990906) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14618854969739914) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5400970131158829) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8048931956291199) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.426584854722023) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5871250033378601) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.2402190864086151) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748504251241684) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.923337996006012) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2869911938905716) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05177626945078373) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8075879812240601) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.09588830173015594) { - if (averageDuration_2 <= -0.2508274167776108) { - if (maxDuration_2 <= -0.3264417052268982) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5148786902427673) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.21237558871507645) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.14633847028017044) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.27885277569293976) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.2445913553237915) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (averageDuration_2 <= -0.27563507854938507) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.24052101373672485) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.20517390221357346) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14677874743938446) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (maxDuration_2 <= -0.21784735471010208) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.032900355756282806) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (maxDuration_2 <= -0.3064814358949661) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.509726345539093) { - if (averageDuration_2 <= -0.2846863716840744) { - if (averageDuration_2 <= -0.2861618399620056) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.638380229473114) { - if (maxDuration_2 <= -0.40449170768260956) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8382810354232788) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7233429849147797) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2029322683811188) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12909957766532898) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13346882164478302) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6535920202732086) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7258325517177582) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.2228839173913002) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.4869600981473923) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5292870253324509) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.2791253328323364) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987979784607887) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7233713269233704) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4482111483812332) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.39988990128040314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.2833700329065323) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.470812126994133) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (maxDuration_2 <= -0.2741820365190506) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6481418311595917) { - if (averageDuration_2 <= -0.2582439035177231) { - if (maxDuration_2 <= -0.264588326215744) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.22319337725639343) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485465109348297) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.2633528411388397) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7454572916030884) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13470125198364258) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.920521080493927) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 1.2931131720542908) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.83772411942482) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - if (maxDuration_2 <= -0.31173184514045715) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (maxDuration_2 <= -0.25389277935028076) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1721750795841217) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2145916372537613) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14986799657344818) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (maxDuration_2 <= -0.14705628901720047) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8632377088069916) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.2288569137454033) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.20536451786756516) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5798149406909943) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5377739667892456) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485716640949249) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.21907832473516464) { - if (averageDuration_2 <= -0.2604185491800308) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.0836245734244585) { - if (averageDuration_2 <= -0.23343855887651443) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.2561086267232895) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11848346143960953) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6477150321006775) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473682403564) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (averageDuration_2 <= -0.2801646441221237) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.27239806950092316) { - if (maxDuration_2 <= -0.1380498968064785) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07036935165524483) { - if (maxDuration_2 <= -0.13587180525064468) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379605531692505) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.2596648782491684) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.3828223645687103) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.11747943982481956) { - if (averageDuration_2 <= -0.24797318875789642) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6675136685371399) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (maxDuration_2 <= -0.18224287033081055) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.4416525363922119) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.2610100358724594) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15766098350286484) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.3420938104391098) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6679880619049072) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.042957497760653496) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.28055185079574585) { - if (averageDuration_2 <= -0.2677660137414932) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.543742448091507) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.2785010188817978) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.2683720737695694) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.24810295552015305) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (averageDuration_2 <= -0.2773953080177307) { - if (maxDuration_2 <= -0.26856476068496704) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0318717658519745) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.25394001603126526) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.2679593414068222) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.24917978048324585) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8599216341972351) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.00814439170062542) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= -0.4143427312374115) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.958763062953949) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.22441639751195908) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6893966495990753) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4439823776483536) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.691208690404892) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8230580985546112) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.06381170824170113) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.19548644125461578) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.24826394021511078) { - if (maxDuration_2 <= -0.33553922176361084) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - if (averageDuration_2 <= -0.2661000192165375) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.578790932893753) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6279758214950562) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5692433714866638) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7084825038909912) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015798807144) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6006219387054443) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.2842845022678375) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6929503977298737) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225883811712265) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8199627101421356) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044531345367) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9033576548099518) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8406788408756256) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.2612479478120804) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11514891684055328) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.45369894802570343) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.2751935124397278) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9287764430046082) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.25626711547374725) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.2872167229652405) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.410798043012619) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12764527648687363) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (averageDuration_2 <= -0.27349600195884705) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.10608633980154991) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.27582331001758575) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (averageDuration_2 <= -0.2818043678998947) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592867255211) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.45020928978919983) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (numDurations_2 <= -1.837222695350647) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.12759759277105331) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.061789870262146) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.2299851030111313) { - if (maxDuration_2 <= -0.2237512245774269) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7064080238342285) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4093919396400452) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5614892542362213) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.043881820514798164) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.29040390253067017) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (averageDuration_2 <= -0.18496745824813843) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0013210688484832644) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368339061737) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8100003600120544) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (numDurations_2 <= -1.2680706679821014) { - if (maxDuration_2 <= -0.2715988755226135) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.16359472274780273) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.21660760790109634) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.1966957077383995) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3292957693338394) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.039249714463949203) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7054912745952606) { - if (averageDuration_2 <= 0.0009743962436914444) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.41863176226615906) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940378189087) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= -1.837222695350647) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4068650007247925) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.3182181417942047) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.3255345225334167) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7807172238826752) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.2694232314825058) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.48930469155311584) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1483902707695961) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5944550633430481) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5142034292221069) { - if (maxDuration_2 <= -0.03438427112996578) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (maxDuration_2 <= -0.40340517461299896) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.24718830734491348) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.545611709356308) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.2789292186498642) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23131079226732254) { - if (averageDuration_2 <= -0.24193211644887924) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.23222923278808594) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.590805172920227) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6946036517620087) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.27381957322359085) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.294686421751976) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (averageDuration_2 <= -0.19888681173324585) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18907227367162704) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7157882153987885) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.27738210558891296) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486009001731873) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.3579053580760956) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6313998401165009) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17327073961496353) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2521565333008766) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.20408271253108978) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (averageDuration_2 <= -0.15315686911344528) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (averageDuration_2 <= -0.18946343660354614) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6417744755744934) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485648691654205) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.8759267926216125) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.357895165681839) { - if (averageDuration_2 <= 0.06967776082456112) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4892125725746155) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.4436546862125397) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.33277857303619385) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.23737216740846634) { - if (maxDuration_2 <= -0.2776317298412323) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1390169858932495) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.236459419131279) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7210432887077332) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5234153568744659) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.08700080588459969) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.22233781218528748) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.4869600832462311) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6631695926189423) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.42108336091041565) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.15575862675905228) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.596440315246582) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (averageDuration_2 <= -0.23228462785482407) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07731792330741882) { - if (maxDuration_2 <= -0.4351624995470047) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.22395853698253632) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06479034572839737) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.36404065787792206) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.23173528164625168) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (maxDuration_2 <= -0.38920433819293976) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11565437540411949) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.31106923520565033) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.23786932229995728) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7064080834388733) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.608068972826004) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5461540222167969) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5092349648475647) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (maxDuration_2 <= -0.4012725502252579) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.2365148812532425) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.4689917266368866) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - if (averageDuration_2 <= -0.13831698149442673) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= -1.837222695350647) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.516241043806076) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (averageDuration_2 <= -0.2143319770693779) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18428974598646164) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.08554983884096146) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6139990389347076) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.30045635998249054) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5669287443161011) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1942695826292038) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089094400406) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.645479142665863) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.22393422573804855) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (averageDuration_2 <= -0.2688061594963074) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.33296892046928406) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606725335121) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.5612579137086868) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.37244056165218353) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2829601541161537) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (numDurations_2 <= -1.837222695350647) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.29339762032032013) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.152395099401474) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.43922701478004456) { - if (averageDuration_2 <= -0.22077295184135437) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.11248533055186272) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.49333691596984863) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5578545331954956) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.36362679302692413) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.38087184727191925) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5248203873634338) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5377740263938904) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.26057150959968567) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (averageDuration_2 <= -0.2571285516023636) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.07104289624840021) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4283716380596161) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.01868955628015101) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.22864992171525955) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.05839197151362896) { - if (averageDuration_2 <= -0.23892468959093094) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.21237558871507645) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.268309473991394) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5118407309055328) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4169272929430008) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.10460836440324783) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2528271824121475) { - if (averageDuration_2 <= -0.3269695043563843) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.08821799606084824) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (averageDuration_2 <= -0.4989064633846283) { - if (numDurations_2 <= -0.12976673245429993) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4125606417655945) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6339189410209656) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6227197349071503) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.4512444734573364) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.027930138632655144) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.41234298050403595) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5211040675640106) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5165899395942688) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019880056381226) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.39154790341854095) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485997080802917) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6027671992778778) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (maxDuration_2 <= -0.2841053456068039) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4572376608848572) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - if (numDurations_2 <= -0.6989187151193619) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.15789134800434113) { - if (maxDuration_2 <= -0.5957201421260834) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7244468629360199) { - if (averageDuration_2 <= -0.6669583916664124) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5603378117084503) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (maxDuration_2 <= -0.3346400856971741) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5805412530899048) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3296091705560684) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948889613152) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5601940751075745) { - if (maxDuration_2 <= -0.5088740587234497) { - if (averageDuration_2 <= -0.5944306552410126) { - if (averageDuration_2 <= -0.7100886106491089) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.31590230762958527) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.4340621829032898) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5481206774711609) { - if (averageDuration_2 <= -0.5680032074451447) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7477593719959259) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { - if (averageDuration_2 <= -0.5106007158756256) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8261885643005371) { - if (maxDuration_2 <= -0.4827265590429306) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.09361106529831886) { - if (averageDuration_2 <= -0.6067487597465515) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2860908806324005) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8923229575157166) { - if (maxDuration_2 <= -0.4859583228826523) { - if (averageDuration_2 <= -0.5634881258010864) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3086474984884262) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6676608622074127) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6602632999420166) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748130202293396) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4057624936103821) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - if (averageDuration_2 <= -0.6048232018947601) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13716164976358414) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.04838144592940807) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6917317807674408) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (maxDuration_2 <= -0.40035584568977356) { - if (averageDuration_2 <= -0.5483162999153137) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.20353782922029495) { - if (averageDuration_2 <= -0.4006756395101547) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2909836173057556) { - if (maxDuration_2 <= -0.4715954065322876) { - if (averageDuration_2 <= -0.5518810451030731) { - if (maxDuration_2 <= -0.5560278296470642) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.4340621829032898) { - if (maxDuration_2 <= -0.7255154252052307) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5784659087657928) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.07238395884633064) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.32002657651901245) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7415772378444672) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1335732415318489) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (averageDuration_2 <= -0.5721547603607178) { - if (maxDuration_2 <= -0.5978019833564758) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (averageDuration_2 <= -0.6124387979507446) { - if (numDurations_2 <= -0.6989187151193619) { - if (maxDuration_2 <= -0.7166182100772858) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.6833442151546478) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6828599572181702) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.6535961925983429) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2617175728082657) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6647436320781708) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.6605772078037262) { - if (averageDuration_2 <= -0.6295326054096222) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21005327999591827) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (averageDuration_2 <= -0.6623657941818237) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.30005142092704773) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6493828296661377) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.29162636399269104) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.30107834935188293) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3925536572933197) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6797971725463867) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5996951758861542) { - if (maxDuration_2 <= -0.6614028811454773) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 6.13090455532074) { - if (averageDuration_2 <= -0.7003266215324402) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23309477418661118) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6249447762966156) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.6840326488018036) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.34428687393665314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.697542279958725) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6278670728206635) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2851773053407669) { - if (averageDuration_2 <= -0.677367091178894) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.553671658039093) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2714698165655136) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5735555291175842) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6179570853710175) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (averageDuration_2 <= -0.613285630941391) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.279721274971962) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5503088533878326) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (numDurations_2 <= 6.13090455532074) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9142167568206787) { - if (averageDuration_2 <= -0.6831077635288239) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2689694166183472) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { - if (averageDuration_2 <= -0.6909444630146027) { - if (averageDuration_2 <= -0.7082001864910126) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22890909761190414) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.45376919209957123) { - if (averageDuration_2 <= -0.6819539070129395) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6348273754119873) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.23199841380119324) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5225249826908112) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.075559675693512) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6110276579856873) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19313225895166397) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5204704403877258) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8383578360080719) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (averageDuration_2 <= -0.7202321588993073) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.7384777069091797) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (averageDuration_2 <= -0.5870723724365234) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.27039894461631775) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.675494909286499) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.0620607640594244) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2073439210653305) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.6364002823829651) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (averageDuration_2 <= -0.5857506990432739) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4358774423599243) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.36888784170150757) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486106753349304) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486236691474915) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485497295856476) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.34155137836933136) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485657334327698) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22496283054351807) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.37853653728961945) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - if (averageDuration_2 <= -0.5964904129505157) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3772291988134384) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485852241516113) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.03190133138559759) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6042692065238953) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6542653739452362) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.2110331878066063) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2523317188024521) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.654164582490921) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5827449262142181) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.5934374332427979) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2944009602069855) { - if (averageDuration_2 <= -0.593600869178772) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (maxDuration_2 <= -0.6688591241836548) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3128224015235901) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6227197349071503) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6261325776576996) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.6348983645439148) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5342010855674744) { - if (averageDuration_2 <= -0.5942671597003937) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37196215987205505) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486171722412109) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18949556350708008) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5878232419490814) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.27998705208301544) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.6678718030452728) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (maxDuration_2 <= -0.8009085953235626) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.671004444360733) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4962782859802246) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.36940766870975494) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.6031054854393005) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3396105617284775) { - if (averageDuration_2 <= -0.6483062207698822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (maxDuration_2 <= -0.6150900423526764) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4051479548215866) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (averageDuration_2 <= -0.6408379077911377) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (numDurations_2 <= 6.415480613708496) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.23457122594118118) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.28192557394504547) { - if (maxDuration_2 <= -0.5394309759140015) { - if (averageDuration_2 <= -0.5908102691173553) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6502960324287415) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6983753442764282) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6154563724994659) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5918280184268951) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.5966546833515167) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748603343963623) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.32093851268291473) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (maxDuration_2 <= -0.5681339204311371) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5143053084611893) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4645354598760605) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486209571361542) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.2592367082834244) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7213721871376038) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.34241510927677155) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (maxDuration_2 <= -0.5081599652767181) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.6422117650508881) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5328779518604279) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.47682543098926544) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.6048415005207062) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21266530454158783) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8261885643005371) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.4923633635044098) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486149668693542) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.6856320798397064) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4740087240934372) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7619648277759552) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5274665653705597) { - if (maxDuration_2 <= -0.13781708106398582) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.23199841380119324) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.4944934695959091) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5897004306316376) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.4340621829032898) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486236691474915) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.5842593312263489) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.3320669084787369) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.4000113755464554) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41197963058948517) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485391795635223) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.47122809290885925) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.25654685497283936) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.38799265027046204) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748023122549057) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2081424444913864) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (averageDuration_2 <= -0.4024594724178314) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.25328144431114197) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.14234451204538345) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2625197470188141) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485034465789795) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5339661836624146) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3545491695404053) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.5819776952266693) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485716640949249) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6240127682685852) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.5514624118804932) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.46276040375232697) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1424911804497242) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.5850118398666382) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.20209894329309464) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.6265810132026672) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (maxDuration_2 <= -0.6034879088401794) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.20224648714065552) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (maxDuration_2 <= -0.5570053458213806) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.29953649640083313) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3239108622074127) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (averageDuration_2 <= -0.5638058185577393) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7576421499252319) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486049830913544) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (maxDuration_2 <= -0.6348981857299805) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.46621835231781006) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7406724989414215) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.5700456202030182) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (maxDuration_2 <= -0.575884073972702) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5352407395839691) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2621181756258011) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2664329558610916) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3543331176042557) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.31939294934272766) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485619187355042) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - if (maxDuration_2 <= -0.5826969146728516) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (maxDuration_2 <= -0.4901042878627777) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (averageDuration_2 <= -0.522789865732193) { - if (maxDuration_2 <= -0.6233289837837219) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2803456336259842) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486171722412109) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.5542067289352417) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2857186198234558) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2899581640958786) { - if (averageDuration_2 <= -0.5093207061290741) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.5321793258190155) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.35915620625019073) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.301122322678566) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6077126562595367) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5589925646781921) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - if (averageDuration_2 <= -0.5597261488437653) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486274838447571) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0462590157985687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (averageDuration_2 <= -0.5663965940475464) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.31620649993419647) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3435003161430359) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5924984514713287) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (maxDuration_2 <= -0.5942942202091217) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486009001731873) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22941620647907257) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.5463476479053497) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (maxDuration_2 <= -0.48249855637550354) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.32127560675144196) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6031866371631622) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6094876825809479) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748561680316925) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3328823745250702) { - if (averageDuration_2 <= -0.45805636048316956) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484555244445801) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.36929039657115936) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5346470773220062) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.38214685022830963) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3405192345380783) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485911548137665) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0761001892387867) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.5372048020362854) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (averageDuration_2 <= -0.531667560338974) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6945921778678894) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.8463466763496399) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3342519551515579) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21165285259485245) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7459463477134705) { - if (maxDuration_2 <= -0.5889197587966919) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (averageDuration_2 <= -0.4584030658006668) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3487404137849808) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.5675159692764282) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3800422102212906) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.5062882900238037) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - if (maxDuration_2 <= -0.6159765422344208) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5691476166248322) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.20891018211841583) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.5460633635520935) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3088129311800003) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.619623601436615) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5251013040542603) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21084773540496826) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5504649579524994) { - if (averageDuration_2 <= -0.5697771608829498) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37935376167297363) { - if (maxDuration_2 <= -0.6679753065109253) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2789972722530365) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3854460269212723) { - if (averageDuration_2 <= -0.5441325902938843) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.602842390537262) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (maxDuration_2 <= -0.48951922357082367) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.5225012302398682) { - if (maxDuration_2 <= -0.4053274393081665) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5596130192279816) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - if (maxDuration_2 <= -0.4567512422800064) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486073970794678) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (averageDuration_2 <= -0.5409604907035828) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.44185522198677063) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5417773127555847) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2298821285367012) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05795922130346298) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9802378714084625) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.532802164554596) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (maxDuration_2 <= -0.28282102942466736) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7476115524768829) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (averageDuration_2 <= -0.3565696179866791) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.4050462692975998) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.41245976090431213) { - if (maxDuration_2 <= -0.3913572132587433) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.36205707490444183) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.47941450774669647) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (averageDuration_2 <= -0.3780890852212906) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.4443804621696472) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.3648296147584915) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.4354717582464218) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.016184553503990173) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.30098845064640045) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485493421554565) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8067096173763275) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.47056202590465546) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4476628750562668) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485440671443939) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.4398176968097687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.372219517827034) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7445995807647705) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5907306969165802) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6031337678432465) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.13044001534581184) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2605813145637512) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.7367621660232544) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.35472045838832855) { - if (averageDuration_2 <= -0.4002620726823807) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.2005058526992798) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.4493653178215027) { - if (maxDuration_2 <= -0.39770668745040894) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4684649854898453) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42437972128391266) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.34205032885074615) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.43551841378211975) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3357419818639755) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.45398305356502533) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.47470422089099884) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4613882303237915) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.49327416718006134) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.21275942027568817) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.33707955479621887) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (maxDuration_2 <= -0.3635760247707367) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.23939812928438187) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3574554771184921) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (averageDuration_2 <= -0.3500021994113922) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.33107639849185944) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (maxDuration_2 <= -0.18180231750011444) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.30909237265586853) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4716014862060547) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (maxDuration_2 <= -0.2960367202758789) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.39227962493896484) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.256836473941803) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.23078802227973938) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.5512620806694031) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5726881623268127) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3110172003507614) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2501889690756798) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19596286863088608) { - if (maxDuration_2 <= -0.6544354259967804) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.34702758491039276) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5878972709178925) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6396775543689728) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5722808837890625) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (averageDuration_2 <= -0.6554039716720581) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8067096173763275) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5686486065387726) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6054034233093262) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6294295191764832) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.30324502289295197) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.36107607185840607) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41816259920597076) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.35040828585624695) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485269904136658) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.63682821393013) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.40183626115322113) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (averageDuration_2 <= -0.559341698884964) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - if (maxDuration_2 <= -0.6690009832382202) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5656287372112274) { - if (maxDuration_2 <= -0.3573988378047943) { - if (numDurations_2 <= 1.5776891708374023) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5687164962291718) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4740087240934372) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3236040025949478) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5834030210971832) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21639560908079147) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3730756640434265) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.5897201001644135) { - if (averageDuration_2 <= -0.5544480085372925) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485714256763458) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.74849534034729) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.5902937650680542) { - if (maxDuration_2 <= -0.7323030829429626) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.03208610601723194) { - if (maxDuration_2 <= -0.6254056394100189) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5314352512359619) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3081260472536087) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.05089460499584675) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (averageDuration_2 <= -0.5116576254367828) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (maxDuration_2 <= -0.5309035181999207) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.4960829168558121) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3295358568429947) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.35200248658657074) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6280775666236877) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5738554298877716) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.36422911286354065) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (maxDuration_2 <= -0.457050159573555) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.4883769005537033) { - if (maxDuration_2 <= -0.5169533491134644) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.34977318346500397) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.47888369858264923) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (maxDuration_2 <= -0.4213823080062866) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.27067437767982483) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.40454475581645966) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.49495241045951843) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.28387095034122467) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2880137711763382) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.6369091868400574) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.5352841317653656) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5226706564426422) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.20181266218423843) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.509487122297287) { - if (averageDuration_2 <= -0.5486159026622772) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6134843826293945) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2942192256450653) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486171722412109) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.5799059271812439) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.4418666213750839) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.4680694490671158) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22761642187833786) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.4513641744852066) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3061124086380005) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6020664870738983) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5520569384098053) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.7944985032081604) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6395776867866516) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.17619893699884415) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5170868337154388) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541474819183) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.7624516487121582) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - if (maxDuration_2 <= -0.277872271835804) { - if (maxDuration_2 <= -0.6453761756420135) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.05396449379622936) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744439005851746) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (maxDuration_2 <= -0.6199630796909332) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.05793486721813679) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.5376519560813904) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.7561812698841095) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.46614550054073334) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093146696686745) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2467629760503769) { - if (averageDuration_2 <= -0.5239435434341431) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3645829558372498) { - if (averageDuration_2 <= -0.5707944333553314) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.43731024861335754) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6444163620471954) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0022448897361755) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5204966366291046) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7698073387145996) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (averageDuration_2 <= -0.46517519652843475) { - if (maxDuration_2 <= -0.520278811454773) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.630760133266449) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.28276537358760834) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8261885643005371) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283403396606) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11433595791459084) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (averageDuration_2 <= -0.6412354707717896) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (numDurations_2 <= 6.415480613708496) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.45020928978919983) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.20738837867975235) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07385984063148499) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404551506042) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.12097278609871864) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4630904495716095) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1081945039331913) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7278706133365631) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5485115051269531) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09539277479052544) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07248801738023758) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { - if (averageDuration_2 <= -0.6985616981983185) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.723607748746872) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5774365663528442) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (averageDuration_2 <= -0.727884829044342) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.7102107107639313) { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.723490446805954) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.6875452995300293) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.7127822041511536) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.7489252388477325) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.018933151848614216) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.041255585849285126) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.283527672290802) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.36245162785053253) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (maxDuration_2 <= -0.7658460438251495) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27466876804828644) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4613555371761322) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (averageDuration_2 <= -0.6644099652767181) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6853641867637634) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5215021222829819) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.013588526286184788) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.45482900738716125) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13350923731923103) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.3457206040620804) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.07133554667234421) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6090952157974243) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485684156417847) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07354965060949326) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.453784704208374) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.39596104621887207) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6337987780570984) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.4230196475982666) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5333801209926605) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703441977500916) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - if (maxDuration_2 <= -0.6080213785171509) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3643207997083664) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.74850994348526) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6328724920749664) { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.7175930738449097) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.04844321496784687) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0708580613136292) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4902585446834564) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (averageDuration_2 <= -0.6429785192012787) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2228042185306549) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485164403915405) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618085026741028) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6042692065238953) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4520620703697205) { - if (averageDuration_2 <= -0.5575141310691833) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4418955445289612) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.25773440301418304) { - if (maxDuration_2 <= -0.6011247932910919) { - if (averageDuration_2 <= -0.5850869715213776) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.1678913831710815) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.06258528865873814) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.513752281665802) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.298371821641922) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (maxDuration_2 <= -0.6554587483406067) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2029322981834412) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.10438440088182688) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.4010435938835144) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5735531747341156) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.0718897394835949) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485456764698029) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.2076711803674698) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5692130029201508) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5804140269756317) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7483691573143005) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5611658096313477) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4235472083091736) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5183549225330353) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.43246516585350037) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09786381945014) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.25357477366924286) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344535857439041) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5576917231082916) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12854060530662537) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9475547671318054) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5888699293136597) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.6226044595241547) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5959138870239258) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4745524674654007) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2521565333008766) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2858542650938034) { - if (maxDuration_2 <= -0.5450409948825836) { - if (averageDuration_2 <= -0.5867359936237335) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5827563405036926) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.168618083000183) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.35733550786972046) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.389140322804451) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.434324249625206) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.351614311337471) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07635049149394035) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.47842347621917725) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.004393589682877064) { - if (averageDuration_2 <= -0.48636777698993683) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4185950756072998) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (maxDuration_2 <= -0.5382533371448517) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.05510523542761803) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.11081308498978615) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6334449350833893) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485879063606262) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485797703266144) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= -1.837222695350647) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (averageDuration_2 <= -0.5299005508422852) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - if (averageDuration_2 <= -0.49599309265613556) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { - if (maxDuration_2 <= -0.6620412170886993) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5728169679641724) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.17110247910022736) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486147284507751) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.5826235711574554) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9895495176315308) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12510943040251732) { - if (numDurations_2 <= 1.0085372477769852) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4932494163513184) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5407021641731262) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.04984685033559799) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.06767288595438004) { - if (averageDuration_2 <= -0.509421706199646) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.46744465827941895) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.35576219856739044) { - if (averageDuration_2 <= -0.5209194421768188) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.6844632029533386) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.01140963239595294) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6665643751621246) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4243810325860977) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8481956124305725) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.35142163932323456) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.2889275699853897) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - if (averageDuration_2 <= -0.45766882598400116) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7238774597644806) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9142167270183563) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.583746999502182) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.319937065243721) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (maxDuration_2 <= -0.563392847776413) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.11044968664646149) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6327060759067535) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (averageDuration_2 <= -0.49942104518413544) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615192413330078) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - if (numDurations_2 <= 3.2851450443267822) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.16891080141067505) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5402468740940094) { - if (maxDuration_2 <= -0.5712746381759644) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5074861943721771) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4345245957374573) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.5376105308532715) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.649873822927475) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1424911804497242) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6931098997592926) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619413614273071) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.07493534963577986) { - if (maxDuration_2 <= -0.5544473826885223) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.1318272426724434) { - if (maxDuration_2 <= -0.48495782911777496) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (averageDuration_2 <= -0.5551666021347046) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1967049166560173) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485508024692535) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484709322452545) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (averageDuration_2 <= -0.47925202548503876) { - if (maxDuration_2 <= -0.6836399137973785) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.5274514257907867) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5878421664237976) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23256254941225052) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4967978149652481) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (averageDuration_2 <= -0.48712828755378723) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.218268733471632) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5137658715248108) { - if (averageDuration_2 <= -0.5585663020610809) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.4870954751968384) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.5877294838428497) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6611500382423401) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (averageDuration_2 <= -0.5437621176242828) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5578376948833466) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.17073660716414452) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.46949028968811035) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.45505067706108093) { - if (averageDuration_2 <= -0.5653768181800842) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.4901810586452484) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4992946982383728) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (averageDuration_2 <= -0.5308720469474792) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.23538777232170105) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4118057042360306) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.47901709377765656) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6025554835796356) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (averageDuration_2 <= -0.5317646265029907) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6040748059749603) { - if (averageDuration_2 <= -0.5247578322887421) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.17203358560800552) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.44016341865062714) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5145729184150696) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291220307350159) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.4436039924621582) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4051479548215866) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8526124060153961) { - if (averageDuration_2 <= -0.3838379234075546) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.390558585524559) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9677406549453735) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.3247819542884827) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514857307076) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6281251758337021) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485651671886444) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.14211505651474) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836058139801025) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5515397191047668) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.40896493196487427) { - if (maxDuration_2 <= -0.3392142057418823) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5169866383075714) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.2005058526992798) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09705497696995735) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.23222923278808594) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.8557784855365753) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485814094543457) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.27381957322359085) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.05475788190960884) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.14856670051813126) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485676109790802) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14788035303354263) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.067494750022888) { - if (maxDuration_2 <= -0.2984352558851242) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 0.4393852949142456) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1161888241767883) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.124604046344757) { - if (maxDuration_2 <= -0.3766549229621887) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.581117033958435) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.37441979348659515) { - if (averageDuration_2 <= -0.37539370357990265) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.004646758548915386) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.23255515843629837) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.045587968081235886) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.4421444535255432) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7550370395183563) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.5304139256477356) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.688913106918335) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 0.15480923652648926) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (maxDuration_2 <= -0.37563668191432953) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.12511024251580238) { - if (averageDuration_2 <= -0.3516463339328766) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9142167270183563) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.2049425542354584) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.0572613924741745) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.27345573902130127) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5702328383922577) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.25724008679389954) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27581942081451416) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.041750965639948845) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.45641449093818665) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.8431501388549805) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.15357730910182) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.29162636399269104) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4201412945985794) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485862672328949) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20823511481285095) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.510930597782135) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.4138586223125458) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6318988502025604) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.702243834733963) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4546239972114563) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.4283875823020935) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.4602272510528564) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.140251100063324) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2961076498031616) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.23538777604699135) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.736188530921936) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.34018469229340553) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.772491455078125) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617165923118591) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12374766916036606) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8768020272254944) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5622496008872986) { - if (averageDuration_2 <= -0.43720293045043945) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485703229904175) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.2385960519313812) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.12733162194490433) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42567162215709686) { - if (averageDuration_2 <= -0.43235644698143005) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486139237880707) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (maxDuration_2 <= -0.23102258890867233) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.36689135432243347) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.43155695497989655) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - if (maxDuration_2 <= -0.34149082005023956) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5404568910598755) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3411053866147995) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (maxDuration_2 <= -0.29296964406967163) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9264280498027802) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48841245472431183) { - if (numDurations_2 <= 0.15480923652648926) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.44576945900917053) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.27381957322359085) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9738000631332397) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.4056263566017151) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5991550087928772) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.10390245914459229) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (averageDuration_2 <= -0.3480192869901657) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4623116254806519) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.40550215542316437) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613160490989685) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42109276354312897) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (maxDuration_2 <= -0.45442621409893036) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4347403645515442) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.044527769088745) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.1968777179718018) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.24359667301178) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.7064703106880188) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9317687749862671) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3862829953432083) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.766765683889389) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.38537317514419556) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7591971755027771) { - if (averageDuration_2 <= -0.3923813998699188) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.15625761449337006) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.3233163058757782) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.6550031900405884) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.9236379861831665) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7076879441738129) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.463708221912384) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.234639286994934) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6772132217884064) { - if (averageDuration_2 <= -0.3797043263912201) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615964889526367) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.299040973186493) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8721061646938324) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5199248492717743) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9208518266677856) { - if (maxDuration_2 <= -0.4699162393808365) { - if (averageDuration_2 <= -0.3668360561132431) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.38309143483638763) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.36390842497348785) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.602776974439621) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - if (maxDuration_2 <= -0.24398231506347656) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618231654167175) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48208679258823395) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.49404236674308777) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2628833651542664) { - if (averageDuration_2 <= -0.4361456632614136) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6180945336818695) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2561350241303444) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5318169742822647) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.517959475517273) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5568408370018005) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.32207027077674866) { - if (averageDuration_2 <= -0.5349857211112976) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4249383509159088) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.36921538412570953) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6941463351249695) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.49135005474090576) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14120978116989136) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.29927270114421844) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.697102427482605) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5664648115634918) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5530392229557037) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.09434778615832329) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.26528115570545197) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.39096294343471527) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.32073213160037994) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7277062237262726) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5795845687389374) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13825879245996475) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5443798899650574) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.506406307220459) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.49287591874599457) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2133997157216072) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7414428889751434) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.27738118171691895) { - if (averageDuration_2 <= -0.43330565094947815) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6573804020881653) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3103039562702179) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14733772724866867) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4291663020849228) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (averageDuration_2 <= -0.3711360991001129) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2479216530919075) { - if (maxDuration_2 <= -0.38824954628944397) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.640409916639328) { - if (maxDuration_2 <= -0.4615836590528488) { - if (averageDuration_2 <= -0.48789890110492706) { - if (averageDuration_2 <= -0.6482199728488922) { - if (maxDuration_2 <= -0.7167143225669861) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.3774325102567673) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.33030788600444794) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015798807144) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (averageDuration_2 <= -0.6111305356025696) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 1.2931131720542908) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2606446295976639) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (maxDuration_2 <= -0.5164949893951416) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.04641691967844963) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.43847134709358215) { - if (maxDuration_2 <= -0.363069549202919) { - if (averageDuration_2 <= -0.5644111037254333) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2830994576215744) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7383382618427277) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5557722747325897) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5412823259830475) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.656618744134903) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.214928150177002) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612974524497986) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2490918040275574) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7270320355892181) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.32332007586956024) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4036276638507843) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7277178466320038) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.4908767193555832) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1391805112361908) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22522208094596863) { - if (numDurations_2 <= 6.13090455532074) { - if (averageDuration_2 <= -0.5384972393512726) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.12233728542923927) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4202587455511093) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6482833027839661) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.25132977217435837) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (averageDuration_2 <= -0.7067766189575195) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0651512444019318) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18302758783102036) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.27040667831897736) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1653968021273613) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3761455714702606) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22446826100349426) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (averageDuration_2 <= -0.345064714550972) { - if (averageDuration_2 <= -0.45101140439510345) { - if (maxDuration_2 <= -0.5347835123538971) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6334137320518494) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.698310136795044) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06506835110485554) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.472336307168007) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3348274379968643) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09947209432721138) { - if (maxDuration_2 <= -0.34507226943969727) { - if (numDurations_2 <= -1.837222695350647) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.14106550067663193) { - if (maxDuration_2 <= -0.48420827090740204) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (averageDuration_2 <= -0.5775834321975708) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3128224015235901) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2461043894290924) { - if (averageDuration_2 <= -0.6984599828720093) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6498123407363892) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6417047679424286) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.6013825535774231) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4234669357538223) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5181497633457184) { - if (averageDuration_2 <= -0.6755379736423492) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5975435376167297) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2776988297700882) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7321714758872986) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2709021270275116) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6275915205478668) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.20815537124872208) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6345901191234589) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.5085448622703552) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.292544662952423) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.48683492839336395) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.10884817317128181) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.2374681755900383) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.36262382566928864) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.45277877151966095) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7341544330120087) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05183424800634384) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7286860942840576) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6711086630821228) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0086426734924316) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.2677568793296814) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.45147620141506195) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.3333258777856827) { - if (maxDuration_2 <= -0.33079037070274353) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06571466848254204) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2196249961853027) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.5864903926849365) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.44460032880306244) { - if (maxDuration_2 <= -0.5835758149623871) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - if (averageDuration_2 <= -0.630709320306778) { - if (averageDuration_2 <= -0.6793220639228821) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.23369093984365463) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5561647415161133) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5428372919559479) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.737655371427536) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7158686518669128) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.11004803329706192) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.4450313597917557) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13424039259552956) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5037055611610413) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.361900731921196) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7298131585121155) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (averageDuration_2 <= -0.673092782497406) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2664700895547867) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.547487884759903) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (maxDuration_2 <= -0.7230182588100433) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.12341158092021942) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.686084121465683) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5287842154502869) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6280176043510437) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8261885643005371) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21666528284549713) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (averageDuration_2 <= -0.6032013297080994) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6914869248867035) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.677620530128479) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.31649768352508545) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5158794224262238) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3611845374107361) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5999850630760193) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4770069122314453) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3063729256391525) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19488123804330826) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2643429785966873) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5583013296127319) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { - if (averageDuration_2 <= -0.5972942411899567) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6914103925228119) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.7100331485271454) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13424547016620636) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (maxDuration_2 <= -0.5624151825904846) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5656762719154358) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2829601541161537) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.035072119906544685) { - if (maxDuration_2 <= -0.4018147885799408) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5542802214622498) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - if (maxDuration_2 <= -0.5273146629333496) { - if (averageDuration_2 <= -0.5746402442455292) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13003522530198097) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7048696279525757) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5771014392375946) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.545533299446106) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5922427773475647) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5762869417667389) { - if (maxDuration_2 <= -0.5175561606884003) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6963981688022614) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - if (maxDuration_2 <= -0.5399450957775116) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7043047845363617) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.526005893945694) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2214813232421875) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3367506414651871) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3372919410467148) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41417986154556274) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.45512649416923523) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (maxDuration_2 <= -0.44399407505989075) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5708211660385132) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6746354103088379) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4630458503961563) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6417805850505829) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.623101145029068) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.5024031102657318) { - if (numDurations_2 <= -1.837222695350647) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8085120916366577) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.659948855638504) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (numDurations_2 <= 2.7159931659698486) { - if (maxDuration_2 <= -0.5664370656013489) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (averageDuration_2 <= -0.5570454895496368) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.24933598190546036) { - if (maxDuration_2 <= -0.5722824931144714) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4135807454586029) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7357318699359894) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.5621263980865479) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6200696229934692) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.028598006814718246) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.5530106127262115) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6916634142398834) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.43749935925006866) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (averageDuration_2 <= -0.49421823024749756) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.23797837644815445) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6974388062953949) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5376870632171631) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6072010397911072) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5791914165019989) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835330963135) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6482833027839661) { - if (averageDuration_2 <= -0.5688181519508362) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 0.7239611893892288) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5713125467300415) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3368874192237854) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3814961165189743) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3977942019701004) { - if (averageDuration_2 <= -0.5704577565193176) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19602637737989426) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7521025836467743) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3981564790010452) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.49859820306301117) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4911867529153824) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6242700219154358) { - if (averageDuration_2 <= -0.5163898468017578) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.708705335855484) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.44626088440418243) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.24538759142160416) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.42407001554965973) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5593899190425873) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.5236605107784271) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3216704875230789) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.44792725145816803) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.47237007319927216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.2337476909160614) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781625390052795) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7292173206806183) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.2668449580669403) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541474819183) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.4445071965456009) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.45373593270778656) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.21934884041547775) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5852096378803253) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8547589480876923) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5622245073318481) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.557945728302002) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3350065350532532) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5343659818172455) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15526005625724792) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.40183354914188385) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5234972238540649) { - if (maxDuration_2 <= -0.3928743153810501) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616023302078247) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.23199841380119324) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.04928279668092728) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (numDurations_2 <= 2.1468411684036255) { - if (numDurations_2 <= 1.008537232875824) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.337710976600647) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7439393699169159) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8254699110984802) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616238474845886) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.21828186511993408) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.6321735382080078) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.730016827583313) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6305622458457947) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.47293439507484436) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - if (averageDuration_2 <= -0.4320108890533447) { - if (numDurations_2 <= 0.43938523530960083) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.4157150834798813) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.2542518377304077) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6388580799102783) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.166086733341217) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.48326602578163147) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.32558687031269073) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (maxDuration_2 <= -0.6191702485084534) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.156201720237732) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.161419987678528) { - if (averageDuration_2 <= -0.6748499274253845) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4000852704048157) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281765937805) { - if (averageDuration_2 <= -0.5494985282421112) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5737024247646332) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9177278280258179) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1946990117430687) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3983716368675232) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8067096173763275) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5572637617588043) { - if (averageDuration_2 <= -0.518149197101593) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.1186873316764832) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.16146307438611984) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.3563174158334732) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.09413566067814827) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.05684150941669941) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.5465984344482422) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.23199841380119324) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.253749817609787) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2225511223077774) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1072198674082756) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.36019499599933624) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6094368696212769) { - if (maxDuration_2 <= -0.3709183484315872) { - if (maxDuration_2 <= -0.6648372411727905) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6555396616458893) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485383749008179) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6975129544734955) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2556520104408264) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7075973153114319) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (maxDuration_2 <= -0.6365318894386292) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.8602667450904846) { - if (maxDuration_2 <= -0.757017195224762) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6804555952548981) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5342106223106384) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.186086654663086) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7115999162197113) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.7624516487121582) { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.6734027564525604) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6529046297073364) { - if (maxDuration_2 <= -0.6433322727680206) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.6463054418563843) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.4340621829032898) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.080590009689331) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.7132413387298584) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5125462412834167) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.4400789737701416) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.3098171651363373) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6286531686782837) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (averageDuration_2 <= -0.4446439743041992) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.2406394481658936) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.8750421404838562) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -4.573187351226807) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.5961335301399231) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5332579910755157) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485911548137665) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6125175654888153) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2644031196832657) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - if (averageDuration_2 <= -0.5024373829364777) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0749278664588928) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - if (maxDuration_2 <= -0.6097739338874817) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2044304013252258) { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.04252815246582) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -5.132140636444092) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.418075323104858) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7098519206047058) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.2578715980052948) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0072121620178223) { - if (cpuCoreIdleTimesPercentage_4_2 <= -5.077812194824219) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.224177598953247) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - if (maxDuration_2 <= -0.3920004367828369) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.981752872467041) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.23331590741872787) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.27022354304790497) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.13589466363191605) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486179769039154) { - if (maxDuration_2 <= -0.45124760270118713) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7482962906360626) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6450034379959106) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -5.00006628036499) { - if (maxDuration_2 <= -0.09045055136084557) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.4905432164669037) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.5110598504543304) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.1122801303863525) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.8666034936904907) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.5144936740398407) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.1618149280548096) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6532392501831055) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5448073446750641) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5200567543506622) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5460343062877655) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.553584098815918) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.442190483212471) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.338785767555237) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.6955958008766174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.6098474264144897) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.601281613111496) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.7946025133132935) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (maxDuration_2 <= -0.35139642655849457) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2707897275686264) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.178974449634552) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5588911771774292) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9475547671318054) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.051593413576483727) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.5986001789569855) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.358581781387329) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9635092914104462) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8787583112716675) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.7946025133132935) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.6885001957416534) { - if (maxDuration_2 <= -0.7354182600975037) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.44804389774799347) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7328802049160004) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8303544819355011) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.331404209136963) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5573742091655731) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.4389121532440186) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.517542123794556) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.2484651878476143) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.6181628704071045) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.04611337184906) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.25996068120002747) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (maxDuration_2 <= -0.0819484256207943) { - if (averageDuration_2 <= -0.5043905973434448) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.521897166967392) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.976557970046997) { - if (cpuCoreIdleTimesPercentage_4_2 <= -5.2091405391693115) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6094190180301666) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6490458250045776) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617186188697815) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.6821833848953247) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.529633283615112) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.028396189212799) { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.867992162704468) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7657618224620819) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.74553120136261) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.7650195360183716) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5331178307533264) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.6021633446216583) { - if (cpuCoreIdleTimesPercentage_5_2 <= -5.00006628036499) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.7046387195587158) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -5.165159225463867) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { - if (maxDuration_2 <= -0.6883735656738281) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8814854323863983) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.579344987869263) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6841802000999451) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.2831013202667236) { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.471769332885742) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.183059215545654) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0755597352981567) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.2214196920394897) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6198905408382416) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.9040391147136688) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.835999369621277) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6571447551250458) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7094923555850983) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.312984347343445) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.6086798906326294) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - if (maxDuration_2 <= -0.6234631240367889) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575631141663) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.5802741050720215) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9582308232784271) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.576667785644531) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.435875177383423) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.34235675632953644) { - if (maxDuration_2 <= -0.5609462559223175) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.399004578590393) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2776988297700882) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.6442541480064392) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (averageDuration_2 <= -0.719832569360733) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.690115809440613) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619999527931213) { - if (averageDuration_2 <= -0.6976645290851593) { - if (averageDuration_2 <= -0.7120301425457001) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.021669305860996246) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.237821340560913) { - if (averageDuration_2 <= -0.725535660982132) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.449406385421753) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.7316962480545044) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6897306144237518) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.8557784855365753) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485684156417847) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613062739372253) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.134287178516388) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.2508179843425751) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.4812127351760864) { - if (maxDuration_2 <= -0.41614462435245514) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - if (maxDuration_2 <= -0.4874374270439148) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.0095096826553345) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485253810882568) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.158935070037842) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.516908645629883) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.9623591303825378) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.1120288372039795) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9428106844425201) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.9108937978744507) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.0890586376190186) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -5.143476486206055) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.850223660469055) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.10788631439209) { - if (maxDuration_2 <= -0.3914356827735901) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - if (averageDuration_2 <= -0.6922805905342102) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.749491214752197) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.4815565198659897) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7619648277759552) { - if (averageDuration_2 <= -0.5128662288188934) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.086333751678467) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473013162613) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.2385960817337036) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.9535809755325317) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (averageDuration_2 <= -0.5117494165897369) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.8602667450904846) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.886878728866577) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.158935070037842) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.925930917263031) { - if (maxDuration_2 <= -0.49972596764564514) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462536096573) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3751400709152222) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { - if (averageDuration_2 <= -0.48433932662010193) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.8568262457847595) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.18692073225975037) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.41119202971458435) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.434475600719452) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.298130601644516) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.06767288595438004) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.04049695283174515) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.42356060445308685) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.754804491996765) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.173550605773926) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.09615419059991837) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.3602466583251953) { - if (averageDuration_2 <= -0.5146668255329132) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4387903809547424) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8633034825325012) { - if (averageDuration_2 <= -0.5768377780914307) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.155755639076233) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.27381957322359085) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.622730255126953) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.516908645629883) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.8113982677459717) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.154330015182495) { - if (maxDuration_2 <= -0.47224630415439606) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.603843688964844) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5238292664289474) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.1618149280548096) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.117706298828125) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.6362186670303345) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.2490766644477844) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.3791850507259369) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.2170642614364624) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486204206943512) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.662456214427948) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.2542518377304077) { - if (maxDuration_2 <= -0.6105034649372101) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.24946820735931396) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.717059016227722) { - if (maxDuration_2 <= -0.48593053221702576) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.556496858596802) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.0371131300926208) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6401868760585785) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.7647639513015747) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4158035516738892) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.10788631439209) { - if (maxDuration_2 <= -0.5283782482147217) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4557486176490784) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.6321735382080078) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.3048789501190186) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.830192446708679) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.227532625198364) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7089749872684479) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485463321208954) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618495106697083) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.092849254608154) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.174108386039734) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4623605608940125) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.23927905410528183) { - if (averageDuration_2 <= -0.43246816098690033) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.8958566188812256) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.334665775299072) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485310435295105) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.6982106566429138) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.08448600769043) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.282440185546875) { - if (maxDuration_2 <= -0.5391396284103394) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.423806831240654) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1980973184108734) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.8949843645095825) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3978457450866699) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.6440365314483643) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3345415592193604) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4761110693216324) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.9915950894355774) { - if (averageDuration_2 <= -0.6847762763500214) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6922973990440369) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4863396883010864) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4622823596000671) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (averageDuration_2 <= -0.41235609352588654) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484157085418701) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9254318177700043) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3456021100282669) { - if (averageDuration_2 <= -0.5058168768882751) { - if (maxDuration_2 <= -0.15823808312416077) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5783149600028992) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5788074433803558) { - if (maxDuration_2 <= -0.4997640401124954) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.537091463804245) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.1516360640525818) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3741144388914108) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.802748203277588) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6712677776813507) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.0572593212127686) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461759626865387) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.696106195449829) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.1885876655578613) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.6321735382080078) { - if (maxDuration_2 <= -0.3878088891506195) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.4205806255340576) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.646065831184387) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.358581781387329) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.6482369899749756) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.8841458559036255) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.160470485687256) { - if (averageDuration_2 <= -0.6046889126300812) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.42461895942688) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.11321438103914261) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7227886617183685) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.358581781387329) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5269295275211334) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6453381180763245) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5331178307533264) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.672433465719223) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.6265538930892944) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.15253791213035583) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6037487685680389) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.6752995252609253) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (averageDuration_2 <= -0.5452573299407959) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.2663294672966003) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21048817038536072) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4948030561208725) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.2911977767944336) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.29671233892440796) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.4877901673316956) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0070842504501343) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7821765244007111) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5556832253932953) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.2480701804161072) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.41785596311092377) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7419655919075012) { - if (maxDuration_2 <= -0.25518954545259476) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2076534628868103) { - if (averageDuration_2 <= -0.5084711015224457) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485871016979218) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4568420052528381) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.9615209102630615) { - if (numDurations_2 <= -0.983494758605957) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.537806510925293) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5060377717018127) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13453566655516624) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.5448639094829559) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.622730255126953) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.5675357580184937) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.5524985790252686) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2405078411102295) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.656818687915802) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.522858738899231) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.9925618171691895) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.48583482950925827) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.5956923961639404) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -5.066103458404541) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0801680088043213) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.523518979549408) { - if (maxDuration_2 <= -0.18866080790758133) { - if (averageDuration_2 <= -0.603671669960022) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9701417088508606) { - if (numDurations_2 <= 0.15480923652648926) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3357419818639755) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.405732154846191) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5792979001998901) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.09995614923536777) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.191106557846069) { - if (averageDuration_2 <= -0.5661985576152802) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7360992729663849) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.8154819309711456) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616394639015198) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9784879684448242) { - if (maxDuration_2 <= -0.5637955069541931) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.863446444272995) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4874650686979294) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08139314502477646) { - if (maxDuration_2 <= -0.5161325931549072) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7858922481536865) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.9040391147136688) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.735918045043945) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.5695168673992157) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.370870113372803) { - if (averageDuration_2 <= -0.6768169701099396) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7240088582038879) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.9238688945770264) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (averageDuration_2 <= -0.6179004907608032) { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6577304899692535) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.31682880222797394) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.42187587916851044) { - if (maxDuration_2 <= -0.6253246665000916) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5463889837265015) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { - if (averageDuration_2 <= -0.4222555160522461) { - if (averageDuration_2 <= -0.7240657210350037) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.075546860694885) { - if (numDurations_2 <= 4.4234490394592285) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.851802408695221) { - if (averageDuration_2 <= -0.6874747574329376) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.641070604324341) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514857307076) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4433693587779999) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.31832775473594666) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7010758519172668) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8450019061565399) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6090219914913177) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2633190006017685) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.024194464087486267) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6371949315071106) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6100044250488281) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9714998304843903) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3839026689529419) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.5379742383956909) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3015419691801071) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.10017209872603416) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (averageDuration_2 <= -0.13346248120069504) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.155755639076233) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.2208210974931717) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6068148016929626) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.17705606669187546) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.10984431207180023) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.2003083229064941) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.20772016048431396) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - if (averageDuration_2 <= -0.18303941190242767) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13353464379906654) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.08866410329937935) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7010758519172668) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.2413341999053955) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5502449572086334) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.2397812008857727) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.22954095900058746) { - if (averageDuration_2 <= -0.1960652694106102) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9738000631332397) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.976557970046997) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.3438742607831955) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.043023668229579926) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 0.05132848024368286) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - if (averageDuration_2 <= 0.02000202890485525) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5734407305717468) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1682894602417946) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5522496849298477) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.04628022946417332) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (averageDuration_2 <= -0.033020395785570145) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.19144360721111298) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (maxDuration_2 <= -0.20898312330245972) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (averageDuration_2 <= -0.2202545702457428) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.26031970977783203) { - if (averageDuration_2 <= -0.2403559312224388) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.4863998293876648) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.9968165159225464) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.25775402784347534) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13644146174192429) { - if (averageDuration_2 <= -0.24034695327281952) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 0.7239612340927124) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960161313414574) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485597431659698) { - if (maxDuration_2 <= -0.1797102764248848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.33079805970191956) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5404018759727478) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.625398576259613) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.07682698965072632) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.034901619888842106) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.01704788487404585) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (averageDuration_2 <= -0.0679672323167324) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.47706516087055206) { - if (numDurations_2 <= 0.43938520550727844) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.21765702962875366) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.17289334535598755) { - if (maxDuration_2 <= -0.16121140867471695) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37438835203647614) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.16241279244422913) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.10036905482411385) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.05536891892552376) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9246130585670471) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.002244919538498) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.33512134850025177) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.19440588355064392) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.13940123468637466) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.18252447992563248) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.21213797479867935) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.10375238955020905) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.126961812376976) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (averageDuration_2 <= -0.07220580987632275) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1753498539328575) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.43600231409072876) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.14158286899328232) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.04984685266390443) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (averageDuration_2 <= -0.2507559657096863) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.246923565864563) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.24040105193853378) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.599594235420227) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5125620663166046) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.919897198677063) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5841110944747925) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.3503604382276535) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18842370063066483) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7521025836467743) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6082964241504669) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.31724025309085846) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.289578378200531) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.1264832243323326) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5683162212371826) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (averageDuration_2 <= -0.2389218956232071) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8231029808521271) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.2806929498910904) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5070415735244751) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485823631286621) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.09695343300700188) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.38111309707164764) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.09066027775406837) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.06424967106431723) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.19075536727905273) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.12641269341111183) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.43741314113140106) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - if (averageDuration_2 <= -0.16553089767694473) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3957202136516571) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (averageDuration_2 <= -0.2411782667040825) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.298153281211853) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0024429496843367815) { - if (averageDuration_2 <= -0.06986014544963837) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.03208610601723194) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.49162955582141876) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.1615402102470398) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.20776688307523727) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1201142780482769) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.276912659406662) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (averageDuration_2 <= -0.2622232884168625) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.20909453183412552) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.07351639494299889) { - if (averageDuration_2 <= -0.2259947806596756) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.4765240550041199) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.07129451259970665) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (averageDuration_2 <= -0.2342781275510788) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4840638190507889) { - if (averageDuration_2 <= -0.2690299302339554) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.02817050088196993) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.15083681046962738) { - if (averageDuration_2 <= -0.2679321765899658) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3277653902769089) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3487560451030731) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.3023988902568817) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.716353565454483) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.19543622434139252) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5010741949081421) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.2938232570886612) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2082364857196808) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485513687133789) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485261857509613) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21113988012075424) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.25132977217435837) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26953834295272827) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592867255211) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484966218471527) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8223898708820343) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1986444666981697) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.07856107130646706) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4742172807455063) { - if (averageDuration_2 <= -0.10754148662090302) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.01990731619298458) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.058113276958465576) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.011581110768020153) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.20217006653547287) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.07682698452845216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5841110944747925) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.06753522902727127) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.12285849452018738) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485546171665192) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5749931037425995) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.21451514214277267) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485018074512482) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.28631116449832916) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.07770555093884468) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.30396661162376404) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3798131197690964) { - if (averageDuration_2 <= -0.1773580014705658) { - if (maxDuration_2 <= -0.25428277999162674) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.10438440088182688) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5419613420963287) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.16011209785938263) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.07088297978043556) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5716511011123657) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.22142869979143143) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6807559132575989) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.18290074914693832) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485170066356659) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.31694912910461426) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.38472796976566315) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.36404065787792206) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (averageDuration_2 <= -0.2260044664144516) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.25604359805583954) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.15153738111257553) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09020838141441345) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4232677221298218) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5538188219070435) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.3895184397697449) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.25027691572904587) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.346693679690361) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486009001731873) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.584574431180954) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (averageDuration_2 <= -0.20905528217554092) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.17459945380687714) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (maxDuration_2 <= -0.17008856683969498) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.43513740599155426) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (averageDuration_2 <= -0.25282905995845795) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485954761505127) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718024134635925) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.1181785874068737) { - if (maxDuration_2 <= -0.3301217705011368) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.06744236499071121) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.20490463823080063) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.27727271616458893) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5477399230003357) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (maxDuration_2 <= -0.1728212684392929) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.334991455078125) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.844688057899475) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.25732527673244476) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6492643356323242) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28608469665050507) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617000818252563) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.457713544368744) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (maxDuration_2 <= -0.23593854159116745) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5991550087928772) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485789656639099) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.37850624322891235) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5710813403129578) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.1906251907348633) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.760370969772339) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4352436065673828) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5594193637371063) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.6307660341262817) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.328541338443756) { - if (maxDuration_2 <= -0.34970705211162567) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0739621818065643) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.8508365154266357) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.157551884651184) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.7930396795272827) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486139237880707) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5328285396099091) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.9766682386398315) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.4294387102127075) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.22442620992660522) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.27244462072849274) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5022991895675659) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (maxDuration_2 <= -0.2616579681634903) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2291715145111084) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744439005851746) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.443066120147705) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.487790107727051) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4285300374031067) { - if (averageDuration_2 <= -0.11506064236164093) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.4668562412261963) { - if (averageDuration_2 <= -0.3087059408426285) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3930707573890686) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.0620607640594244) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5961965918540955) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.15266720950603485) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.4125157594680786) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4097729921340942) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { - if (averageDuration_2 <= -0.24292107671499252) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2762174680829048) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.07018454559147358) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404849529266) { - if (averageDuration_2 <= -0.09198318794369698) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.724435418844223) { - if (maxDuration_2 <= -0.2396666184067726) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (averageDuration_2 <= -0.2190263420343399) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541474819183) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.3897310942411423) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (maxDuration_2 <= -0.3375881612300873) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (averageDuration_2 <= -0.1976470947265625) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (averageDuration_2 <= -0.28265000879764557) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.010598020628094673) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (averageDuration_2 <= -0.2693638950586319) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485310733318329) { - if (averageDuration_2 <= -0.10486993938684464) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - if (averageDuration_2 <= -0.21682287752628326) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.528399646282196) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.663274109363556) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3044518083333969) { - if (maxDuration_2 <= -0.2164848893880844) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - if (averageDuration_2 <= -0.25356268882751465) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.5192242860794067) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (averageDuration_2 <= -0.1160062737762928) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6002986431121826) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5863257050514221) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5143053084611893) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.2851201593875885) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.2005058526992798) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - if (maxDuration_2 <= -0.28363431990146637) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.453575611114502) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2297377586364746) { - if (averageDuration_2 <= -0.19054347276687622) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.6065900325775146) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5402499735355377) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4226353168487549) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936677023768425) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5699305534362793) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.35360656678676605) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508574008942) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - if (averageDuration_2 <= -0.020353716798126698) { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4444212913513184) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0925476551055908) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3543331027030945) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.13808871060609818) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.18798432499170303) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.05594206787645817) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.5647449493408203) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.17935819923877716) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485765516757965) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22289638966321945) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.4071969985961914) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5992768108844757) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.47795867919921875) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.10518208518624306) { - if (averageDuration_2 <= -0.2870832085609436) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2518677115440369) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.714409112930298) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.432702660560608) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0970265865325928) { - if (averageDuration_2 <= -0.2447943165898323) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.44806969165802) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2379305958747864) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4292091727256775) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5748830735683441) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13580286130309105) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.2719774842262268) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.2567959576845169) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41412487626075745) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4565791487693787) { - if (maxDuration_2 <= -0.3124081641435623) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3445320874452591) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4620537757873535) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2745468467473984) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.35311898589134216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.25125275552272797) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5572963654994965) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.2406897321343422) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9199509620666504) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.03406105190515518) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612095355987549) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - if (averageDuration_2 <= -0.14517241716384888) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.09434983134269714) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.22163639217615128) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.17004309594631195) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6812559366226196) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1844562441110611) { - if (maxDuration_2 <= -0.452139288187027) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5587128698825836) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3642895817756653) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.2985364645719528) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1424911804497242) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.46517783403396606) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.2806835174560547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32175226509571075) { - if (averageDuration_2 <= -0.30321893095970154) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.21648497134447098) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6001963019371033) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (averageDuration_2 <= -0.15420497953891754) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.359214186668396) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617977142333984) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1858297921717167) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617742896080017) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.13072708249092102) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.36913350224494934) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1784394308924675) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (maxDuration_2 <= -0.2780419886112213) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.510258823633194) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.3669004440307617) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615329504013062) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.23199841380119324) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.2831329107284546) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6901179552078247) { - if (averageDuration_2 <= -0.2523527592420578) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5350112020969391) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (averageDuration_2 <= -0.26994237303733826) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2007369995117188) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0792827308177948) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.588455319404602) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.10004199296236038) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.400429904460907) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5949993133544922) { - if (averageDuration_2 <= -0.24799761921167374) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7686214447021484) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6542955935001373) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.146611124277115) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.14777786284685135) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.729569673538208) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.7307084798812866) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.346752166748047) { - if (averageDuration_2 <= -0.22678132355213165) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3240416944026947) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.28348465263843536) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2106016278266907) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.9265406727790833) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0073401182889938354) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6136592328548431) { - if (averageDuration_2 <= -0.29494817554950714) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5074905455112457) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4343758821487427) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4531906247138977) { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.22801128029823303) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.8518567085266113) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2421379685401917) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5572963654994965) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485286295413971) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5447190701961517) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.31182965636253357) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.3542330414056778) { - if (averageDuration_2 <= -0.23049961775541306) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.25031592696905136) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.20815537124872208) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.22282475978136063) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (averageDuration_2 <= -0.2823459953069687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485852241516113) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.2620607614517212) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (averageDuration_2 <= -0.13310864567756653) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461574912071228) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2264362573623657) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.02741278090979904) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616150259971619) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.2624937742948532) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8295444846153259) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.08784888312220573) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.316119909286499) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9311985075473785) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4269055426120758) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42138414084911346) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.3191892504692078) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.36560143530368805) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.09894521534442902) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4351820349693298) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6693859994411469) { - if (averageDuration_2 <= -0.21764829754829407) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.13483598828315735) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.27366556227207184) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= 0.012071079108864069) { - if (averageDuration_2 <= -0.1938987895846367) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.19929425418376923) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485665678977966) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7075349986553192) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.1362542137503624) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.14084868878126144) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1051284968852997) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8470544517040253) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.0445276498794556) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4207622408866882) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4650612026453018) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5991550087928772) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.05768261104822159) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7152725756168365) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - if (averageDuration_2 <= -0.014967279508709908) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.08551564812660217) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6941463351249695) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.23219355940818787) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (maxDuration_2 <= -0.06512873619794846) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (averageDuration_2 <= 0.033267874270677567) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.22189614176750183) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.080590009689331) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.20673025771975517) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485131919384003) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.7504844069480896) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4358607083559036) { - if (averageDuration_2 <= -0.036771563813090324) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.13137878477573395) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.4314171075820923) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.19815204292535782) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18841815739870071) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.05795177444815636) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486025393009186) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.07658972963690758) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612564444541931) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11745024472475052) { - if (averageDuration_2 <= -0.2065293788909912) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4466978907585144) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.024998968467116356) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (maxDuration_2 <= -0.11620554700493813) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.23222923278808594) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.588432788848877) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616785645484924) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5503934621810913) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.05575621500611305) { - if (maxDuration_2 <= -0.09128132835030556) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.15631073713302612) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7482256293296814) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5813577771186829) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (averageDuration_2 <= -0.15407860279083252) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (averageDuration_2 <= -0.22397392988204956) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7437497973442078) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4611929059028625) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.12891700863838196) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.03910523280501366) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.16688719391822815) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6678706109523773) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066322088241577) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (averageDuration_2 <= -0.21712301671504974) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.28221355378627777) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3758256137371063) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 1.8622652292251587) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7440966665744781) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.44211241602897644) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.2492470145225525) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485499978065491) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.03102345857769251) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.040098683908581734) { - if (maxDuration_2 <= -0.0508721973747015) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5129373222589493) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614078998565674) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.0904808733612299) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.05089460499584675) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.396992802619934) { - if (numDurations_2 <= -1.837222695350647) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5411615967750549) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2793646976351738) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (averageDuration_2 <= 0.02263886108994484) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3577922582626343) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (maxDuration_2 <= -0.030808256939053535) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5823568999767303) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0394643247127533) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26996055990457535) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.16085726767778397) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.13020127266645432) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.7091822624206543) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4549474120140076) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - if (maxDuration_2 <= -0.121772401034832) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.586359828710556) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1399371027946472) { - if (averageDuration_2 <= -0.24770252406597137) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5978710353374481) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7788397669792175) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.2843915671110153) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.3708546161651611) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300742030143738) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.5079384446144104) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.056241512298583984) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.1537500619888306) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.9165481328964233) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9062473177909851) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.648976445198059) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.162411332130432) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7406724989414215) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.16756846755743027) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.0812260508537292) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486204206943512) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7751853168010712) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.7158921957015991) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5393354296684265) { - if (averageDuration_2 <= -0.21893543750047684) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5401894152164459) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.0243793725967407) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.2693729996681213) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.8634464740753174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.634629100561142) { - if (averageDuration_2 <= -0.22250784933567047) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (averageDuration_2 <= -0.23197568953037262) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (maxDuration_2 <= -0.2030058354139328) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4586394429206848) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3186301589012146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.380498468875885) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940378189087) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744439005851746) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3795580714941025) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.8837427794933319) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5412280559539795) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (averageDuration_2 <= -0.18513117730617523) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.36531537771224976) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (maxDuration_2 <= -0.33743615448474884) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485586702823639) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (maxDuration_2 <= -0.19888780266046524) { - if (maxDuration_2 <= -0.3716072142124176) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (maxDuration_2 <= -0.19001320004463196) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - if (maxDuration_2 <= -0.2656038850545883) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4481752514839172) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - if (averageDuration_2 <= -0.21634289622306824) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (averageDuration_2 <= -0.1657920405268669) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3529024124145508) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4170385599136353) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4484801292419434) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.04477715119719505) { - if (averageDuration_2 <= -0.23944104462862015) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.9265406727790833) { - if (averageDuration_2 <= -0.3071551024913788) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.1842944175004959) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1600455641746521) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3908514529466629) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.2430381253361702) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.12002952769398689) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6083272695541382) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.24495743215084076) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1964828372001648) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6917512118816376) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6198905408382416) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2723228335380554) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28074170649051666) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7161533534526825) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.31292930245399475) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13006144016981125) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.2506812959909439) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616023302078247) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3963238000869751) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.10480842366814613) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (averageDuration_2 <= -0.13632949441671371) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618250727653503) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.024194462224841118) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486041486263275) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (maxDuration_2 <= -0.16428355872631073) { - if (averageDuration_2 <= -0.22739523649215698) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486131191253662) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4201867580413818) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37726353108882904) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5813480317592621) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.1516360640525818) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618387818336487) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4517005681991577) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (maxDuration_2 <= -0.16814082115888596) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (maxDuration_2 <= -0.24188528954982758) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.439121663570404) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (averageDuration_2 <= -0.26898907124996185) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2259418368339539) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1352650597691536) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.9594480693340302) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.41071929037570953) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.19193264842033386) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4982703924179077) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.24109670519828796) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.49002355337142944) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3251563608646393) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4896641969680786) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461400032043457) { - if (averageDuration_2 <= -0.23131374269723892) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6899430751800537) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.0399842020124197) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (averageDuration_2 <= -0.20628903061151505) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.39591050148010254) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.22710911184549332) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.18114004284143448) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484611868858337) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.12669262662529945) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.030869334936142) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7406226694583893) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.03943234868347645) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6701188683509827) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.23517612367868423) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.08775846287608147) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5287817716598511) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22426453977823257) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - if (averageDuration_2 <= -0.19299542158842087) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21874354034662247) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.20406494289636612) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.40689530968666077) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485093772411346) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.07386618852615356) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - if (averageDuration_2 <= -0.2352519929409027) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.293758749961853) { - if (averageDuration_2 <= -0.3226594775915146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1193835623562336) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485294342041016) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18289048224687576) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.20736579596996307) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (averageDuration_2 <= -0.25438959896564484) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.2929645776748657) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0896867513656616) { - if (averageDuration_2 <= -0.2406178042292595) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.6146548390388489) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.2596495449542999) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.410082682967186) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485668063163757) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7264962196350098) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7478698492050171) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18027283251285553) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.24800492823123932) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8504891991615295) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4846348911523819) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.5193292051553726) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.008742198580875993) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.06665969640016556) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3183627128601074) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.33321669697761536) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.16020051389932632) { - if (averageDuration_2 <= -0.26541364192962646) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.12983133643865585) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.2312689796090126) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7319779396057129) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7480913400650024) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11754176393151283) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.35916490852832794) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3704606592655182) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613902568817139) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485527396202087) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3520054519176483) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4934031218290329) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4231228828430176) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.45178520679473877) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (averageDuration_2 <= -0.1166103146970272) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0165472328662872) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.16139467805624008) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3379719853401184) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (averageDuration_2 <= -0.21127159148454666) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3325408399105072) { - if (averageDuration_2 <= -0.0858023576438427) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6754916608333588) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618290066719055) { - if (averageDuration_2 <= -0.22487758845090866) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13622060418128967) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615837335586548) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3433229774236679) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2580515518784523) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9441151916980743) { - if (averageDuration_2 <= -0.28417322039604187) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.2008199691772461) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.03790028393268585) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.15835338085889816) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615886807441711) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.18870143964886665) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746412754059) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.08280551806092262) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5418338179588318) { - if (averageDuration_2 <= -0.01565258577466011) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - if (averageDuration_2 <= -0.05734695680439472) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3965482711791992) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.23538777232170105) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.13016829639673233) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.05981086380779743) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5978890359401703) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.16457747668027878) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484904527664185) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4898931384086609) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.33012065291404724) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3854826092720032) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (averageDuration_2 <= -0.13765016943216324) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7655328810214996) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0926169753074646) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (averageDuration_2 <= -0.04015974886715412) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7409540414810181) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.43047793209552765) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.029591891914606094) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.10118158906698227) { - if (averageDuration_2 <= -0.1491527557373047) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.9310524463653564) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4337121397256851) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613492488861084) { - if (maxDuration_2 <= -0.08699353039264679) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470267772675) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.1477046236395836) { - if (averageDuration_2 <= -0.12142528593540192) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962230682373) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619531035423279) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.21404454857110977) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.20802363753318787) { - if (averageDuration_2 <= -0.15815559774637222) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616326093673706) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.07535824552178383) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.08234081417322159) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07672958448529243) { - if (averageDuration_2 <= -0.3150785565376282) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.09115253388881683) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.601638913154602) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.3450782895088196) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (maxDuration_2 <= -0.17468538880348206) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4534631967544556) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.28456349670886993) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.44314736127853394) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6193670630455017) { - if (averageDuration_2 <= -0.25351032614707947) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616873264312744) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.07545875012874603) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.26465658843517303) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5848534405231476) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (maxDuration_2 <= -0.2500811219215393) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.599594235420227) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5708175152540207) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486188113689423) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.26730862259864807) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.015263928566128016) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6499199569225311) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.401174932718277) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.19026003032922745) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.4668562412261963) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (averageDuration_2 <= -0.19253239035606384) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.9437862932682037) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.03999907709658146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.2945640832185745) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5750867426395416) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.28576844930648804) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1848509982228279) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5452868640422821) { - if (maxDuration_2 <= -0.29307354986667633) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.20175477117300034) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4159608781337738) { - if (averageDuration_2 <= -0.22115132957696915) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4901169687509537) { - if (averageDuration_2 <= -0.20688879489898682) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5909576117992401) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3679952770471573) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514787554741) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.28070971369743347) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4620283246040344) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.09204968623816967) { - if (averageDuration_2 <= -0.2580084949731827) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4093919396400452) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.078460942953825) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5991550087928772) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.28613902628421783) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4533283710479736) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6172909438610077) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.342580109834671) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.25963789224624634) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.19963230937719345) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5804057717323303) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617292881011963) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6116690337657928) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.10007137805223465) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.05522541329264641) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4337121397256851) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.08869535103440285) { - if (maxDuration_2 <= -0.15201012790203094) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.09147687628865242) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5388723015785217) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3719324320554733) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1294299215078354) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.1197817362844944) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.43867380917072296) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5945817828178406) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5403359830379486) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (averageDuration_2 <= -0.16917476058006287) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6164050400257111) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485139966011047) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.09939930215477943) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.22089427709579468) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7448217272758484) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617684483528137) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.31761622428894043) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5430162847042084) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.12016559392213821) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588007539511) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.2188083454966545) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2873704582452774) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.03555995970964432) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8477738797664642) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.1645950973033905) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.36921538412570953) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.768029272556305) { - if (maxDuration_2 <= -0.2014787644147873) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3919132500886917) { - if (averageDuration_2 <= -0.3162904977798462) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.25934740900993347) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - if (averageDuration_2 <= -0.5118111073970795) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.28144341707229614) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1390957087278366) { - if (maxDuration_2 <= -0.37317243218421936) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.05752851255238056) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { - if (cpuCoreIdleTimesPercentage_6_2 <= -5.205564856529236) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.3551851958036423) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (averageDuration_2 <= -0.4312569797039032) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.1149210929870605) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.4867181330919266) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.28120526671409607) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.37684209644794464) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615749716758728) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2622058242559433) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4666135311126709) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.42862044274806976) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5380691289901733) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.37636078894138336) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2993045449256897) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7334689199924469) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.14507585763931274) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.32905812561511993) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.48323559761047363) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.5112777054309845) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.45919446647167206) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8782568871974945) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461593508720398) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.06219152361154556) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08275226503610611) { - if (numDurations_2 <= -1.837222695350647) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.45044487714767456) { - if (averageDuration_2 <= -0.6053622364997864) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.4473549723625183) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.33843834698200226) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.4569520801305771) { - if (averageDuration_2 <= -0.6220126152038574) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2229373455047607) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.3298584520816803) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6121294498443604) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 0.15480923652648926) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5428920090198517) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.011927980929613113) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.08234952762722969) { - if (maxDuration_2 <= -0.6117191314697266) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6511207520961761) { - if (numDurations_2 <= -0.4143427312374115) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8239282071590424) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.516137599945068) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.520334839820862) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5135570168495178) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5687973499298096) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.651829332113266) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1319883093237877) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.15393465012311935) { - if (averageDuration_2 <= -0.6868147552013397) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2533997893333435) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.028396189212799) { - if (cpuCoreIdleTimesPercentage_5_2 <= -5.198177814483643) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.059118157252669334) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6342499852180481) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7187130451202393) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06997130066156387) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.10643527284264565) { - if (numDurations_2 <= -0.9834946841001511) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6754916310310364) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.6171745955944061) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8747268617153168) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.6741044223308563) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.523481369018555) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4601464867591858) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 0.43938517570495605) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6768707036972046) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0539959073066711) { - if (averageDuration_2 <= -0.6091971397399902) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.10454852506518364) { - if (averageDuration_2 <= -0.4680220037698746) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.9243354201316833) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.875303789973259) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.06410611793398857) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.23677925765514374) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5737024396657944) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.20792997628450394) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4499615281820297) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9246130585670471) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.004384718486107886) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.33594565093517303) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.06273120269179344) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.0682937353849411) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.3921428471803665) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.35612012445926666) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - if (averageDuration_2 <= -0.47856755554676056) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.79072505235672) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.3884730637073517) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1758318543434143) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5458981096744537) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.010261744144372642) { - if (maxDuration_2 <= -0.4163549244403839) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1433163583278656) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.14197072014212608) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6546749770641327) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.5280866622924805) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.23931897431612015) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.4471777081489563) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4867308884859085) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.23659098893404007) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (maxDuration_2 <= -0.37142235040664673) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.04112440347671509) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3290334641933441) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5476982891559601) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.11801374331116676) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617782235145569) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.3986017107963562) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618172645568848) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400544703006744) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8223898708820343) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.06244852766394615) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.057407304644584656) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0525869727134705) { - if (maxDuration_2 <= -0.3782200962305069) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5356264114379883) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.4643927812576294) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.88081955909729) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.2626097202301025) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2874188423156738) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.328498363494873) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.6285011768341064) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.2807519882917404) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.14924612641334534) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.6401647925376892) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4391323328018188) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.933671712875366) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.016247338615357876) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.267539143562317) { - if (maxDuration_2 <= -0.23914239555597305) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1187252402305603) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - if (averageDuration_2 <= -0.4838390201330185) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.2481638342142105) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.506764680147171) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.41790224611759186) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.0545014007948339) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.45313355326652527) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4303327798843384) { - if (averageDuration_2 <= -0.5682932436466217) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.03880126588046551) { - if (maxDuration_2 <= -0.29738421738147736) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.728938341140747) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.40385177731513977) { - if (averageDuration_2 <= -0.5442897081375122) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9081359207630157) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7406724989414215) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.044527769088745) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.5313072502613068) { - if (maxDuration_2 <= -0.5931037962436676) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4510390758514404) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.36946453154087067) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461394190788269) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.12900884449481964) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.4595877528190613) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (averageDuration_2 <= -0.6007451415061951) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4620595574378967) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.058661652728915215) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6119883358478546) { - if (averageDuration_2 <= -0.5737406313419342) { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2734104990959167) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.16778968274593353) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6981249451637268) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117392778396606) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995391011238) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.45227643847465515) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7822611629962921) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.39174917340278625) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9606459438800812) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.010100342333316803) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.13044002512469888) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.19247598201036453) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643943786621) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.48200465738773346) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { - if (averageDuration_2 <= -0.7134470343589783) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.21485445648431778) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.406023770570755) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.49757325649261475) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2517111152410507) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.27228793501853943) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.8985591530799866) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.272525817155838) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5661364197731018) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5433522164821625) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.31560441851615906) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.18187187612056732) { - if (averageDuration_2 <= -0.4707178622484207) { - if (maxDuration_2 <= -0.4656512290239334) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06485873274505138) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.04570912569761276) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4484865665435791) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.663274109363556) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.26855531334877014) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.36062803864479065) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7002528607845306) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5120779573917389) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6021405160427094) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - if (averageDuration_2 <= -0.35705868899822235) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.19628722965717316) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.033889889717102) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4548403024673462) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2508612722158432) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.513828694820404) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.5002696365118027) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.350590229034424) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7550370395183563) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.19454072415828705) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1795601844787598) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (averageDuration_2 <= -0.3222580850124359) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4727402627468109) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5434605479240417) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.12016559392213821) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.020178772509098053) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.3397738039493561) { - if (maxDuration_2 <= -0.513969898223877) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.366422101855278) { - if (averageDuration_2 <= -0.35798439383506775) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (maxDuration_2 <= -0.27191032469272614) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (maxDuration_2 <= -0.2489742711186409) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1325666606426239) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5525524318218231) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.8431501388549805) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1641283594071865) { - if (cpuCoreIdleTimesPercentage_4_2 <= -5.110644340515137) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4621328711509705) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2472827434539795) { - if (maxDuration_2 <= -0.6596148610115051) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0810356140136719) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - if (maxDuration_2 <= -0.6446768641471863) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4371659755706787) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7204834520816803) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5991550087928772) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.622090995311737) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (averageDuration_2 <= -0.3919198662042618) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.028514383360743523) { - if (averageDuration_2 <= -0.5272644460201263) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.03393502160906792) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.7104121446609497) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.3730001747608185) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.52136766910553) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.6035412549972534) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.31930628418922424) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5565827488899231) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.25013040006160736) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.1604703664779663) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.29069268703460693) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.2566462755203247) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.071472942829132) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.12892761826515198) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (maxDuration_2 <= -0.5506558120250702) { - if (averageDuration_2 <= -0.565261036157608) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1371820904314518) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.2696340084075928) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.39274491369724274) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (averageDuration_2 <= -0.32923445105552673) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614605903625488) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.1934890747070312) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4650067985057831) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2133428454399109) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.36533886194229126) { - if (averageDuration_2 <= -0.6627611815929413) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.35516420006752014) { - if (averageDuration_2 <= -0.4147626906633377) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - if (numDurations_2 <= 1.293113186955452) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.16128583252429962) { - if (averageDuration_2 <= -0.44746164977550507) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.029428482055664) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9049203991889954) { - if (averageDuration_2 <= -0.5005944967269897) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4337121397256851) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2944958209991455) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2503594681620598) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.29451368749141693) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461827039718628) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.326260566711426) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.28546807169914246) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6721392869949341) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.07682698452845216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.4177210032939911) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5054148137569427) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - if (maxDuration_2 <= -0.48509715497493744) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - if (cpuCoreIdleTimesPercentage_0_2 <= -3.016302227973938) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.4159824997186661) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616697430610657) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.24867316335439682) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.32630273699760437) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.4204780161380768) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4214911460876465) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.12016559392213821) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.40805475413799286) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.4535132348537445) { - if (maxDuration_2 <= -0.6082468330860138) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.5203347206115723) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.3382478505373001) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.13689523935318) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.49859820306301117) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4327164590358734) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.4984925836324692) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.03565324656665325) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617606401443481) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614351987838745) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.04049695748835802) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.4622689038515091) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.18598419427871704) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6021405160427094) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.36499546468257904) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899798870087) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2291945442557335) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.13277871906757355) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - if (maxDuration_2 <= -0.38332855701446533) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1920124813914299) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3640940934419632) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461581826210022) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.08722826093435287) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20403236895799637) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.6982106566429138) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.872782826423645) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6383220553398132) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2833772450685501) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.33082449436187744) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.136162631213665) { - if (averageDuration_2 <= -0.33991654217243195) { - if (maxDuration_2 <= -0.4661094844341278) { - if (averageDuration_2 <= -0.3635009080171585) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.46144700050354) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.3455488532781601) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.30242931842803955) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.18870143964886665) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.45089127123355865) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3600654602050781) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.36681056022644043) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - if (averageDuration_2 <= -0.6577690243721008) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3646232932806015) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4302535653114319) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4072736501693726) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3670215606689453) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4437950253486633) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4781753867864609) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5006100237369537) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.5006630420684814) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8827948570251465) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4629302024841309) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.462306797504425) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0394643247127533) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.10430236160755157) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9328933656215668) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.39335161447525024) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.3666815757751465) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.19196250289678574) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (averageDuration_2 <= -0.5932608246803284) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuCoreIdleTimesPercentage_5_2 <= -5.264214992523193) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3734450936317444) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.9649280905723572) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.6040298044681549) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.14462585002183914) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.474169611930847) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.463708221912384) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.337710976600647) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2521565295755863) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8041815459728241) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4606408476829529) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06614914163947105) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6850340664386749) { - if (maxDuration_2 <= -0.36109407246112823) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4436591863632202) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.37817035615444183) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6482833027839661) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.5045659244060516) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (maxDuration_2 <= -0.4038102626800537) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.1465429225936532) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (maxDuration_2 <= -0.37006227672100067) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0018542110919952) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12457386404275894) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.40805475413799286) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461931586265564) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.4169829934835434) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.34106379747390747) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1267523169517517) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2627514600753784) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0567401722073555) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581474900245667) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (averageDuration_2 <= -0.348087415099144) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.12016559392213821) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.894984394311905) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.45725272595882416) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461747944355011) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2559414878487587) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (maxDuration_2 <= -0.5351456105709076) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.48940515518188477) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461400032043457) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.09254208952188492) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.09236176311969757) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5329746305942535) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.191304624080658) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.25455667078495026) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.696106195449829) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.15119463950395584) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541474819183) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.812464714050293) { - if (maxDuration_2 <= -0.25411050021648407) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3614371120929718) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.31057946383953094) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6290831565856934) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= -1.837222695350647) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08403028920292854) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089243412018) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.12471647933125496) { - if (maxDuration_2 <= -0.34866863489151) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5138756781816483) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.22718121856451035) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08122313022613525) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.16704006493091583) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306547224521637) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9250051379203796) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.47468680143356323) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.25981275737285614) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - if (averageDuration_2 <= -0.1449161395430565) { - if (averageDuration_2 <= -0.22330693900585175) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000302791595) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8776583075523376) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3378542512655258) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5792979001998901) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4328937381505966) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.26350855827331543) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6971963346004486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.21226287633180618) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.24943159520626068) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.29946811497211456) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07928066328167915) { - if (averageDuration_2 <= -0.2663479745388031) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13196203112602234) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.7789206802845001) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (averageDuration_2 <= -0.23652255535125732) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.15828602015972137) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.20850521326065063) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.03561710566282272) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.036067111417651176) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.36404065787792206) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.17915936559438705) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.3817836493253708) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.2701772451400757) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.26247355341911316) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.13662757724523544) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4169272929430008) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.043676257133484) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.190030999481678) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0217979708686471) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.7767811566591263) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.372219517827034) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2021644040942192) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.32871532440185547) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3294471204280853) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7766812145709991) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.15424585714936256) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= 0.4393852949142456) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6946036219596863) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0907236859202385) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (maxDuration_2 <= -0.35182175040245056) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3771457076072693) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (maxDuration_2 <= -0.2383040264248848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5552991330623627) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.33037421107292175) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.09878694266080856) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13024823367595673) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5541455149650574) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13734819740056992) { - if (averageDuration_2 <= -0.18964356929063797) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6495687067508698) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.04424252547323704) { - if (maxDuration_2 <= -0.342093825340271) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.24154941737651825) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.32605475187301636) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.30175653100013733) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28368079662323) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3491670787334442) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.10000893846154213) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.13642826676368713) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.26673850417137146) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= -1.837222695350647) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.3594858050346375) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7134557366371155) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.002630658447742462) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2759010195732117) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.638838529586792) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7455261647701263) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.33948375284671783) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.34089985489845276) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5495878458023071) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107351958751678) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.49859820306301117) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.1686181724071503) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.05036983825266361) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.28266914188861847) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - if (averageDuration_2 <= -0.18197216093540192) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2663658559322357) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.10765547677874565) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4108458161354065) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5754210352897644) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4620370864868164) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.1557555198669434) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4400380849838257) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5953681766986847) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.5280866622924805) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.09458231925964355) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (maxDuration_2 <= -0.29755397140979767) { - if (averageDuration_2 <= -0.2869718074798584) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.2443152293562889) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.02348506823182106) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615495800971985) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41980235278606415) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (maxDuration_2 <= -0.21035583317279816) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1729447916150093) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5453493893146515) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4314427375793457) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1434735655784607) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05335359834134579) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856560230255) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.41251610219478607) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.31802448630332947) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461624801158905) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.2729891985654831) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (maxDuration_2 <= -0.37541136145591736) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2203487530350685) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.2847333699464798) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06934653967618942) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613766074180603) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1560530886054039) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.24257842451334) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.11316731944680214) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.31216245889663696) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4353823065757751) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5603935122489929) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (maxDuration_2 <= -0.3513633608818054) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.29338543117046356) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.740801215171814) { - if (averageDuration_2 <= -0.2829168736934662) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.3116227835416794) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09590877592563629) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.29311196506023407) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3994452357292175) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5841034054756165) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687222957611) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.18798432499170303) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.021249395795166492) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.14316435158252716) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618173241615295) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07204516977071762) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4382256269454956) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (averageDuration_2 <= -0.22508987039327621) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.2698106914758682) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.28026944398880005) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.04698444716632366) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2575254589319229) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1808619201183319) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4575757384300232) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.045653900131583214) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (maxDuration_2 <= -0.2499670460820198) { - if (averageDuration_2 <= -0.18946100026369095) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (averageDuration_2 <= -0.24712148308753967) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5372239649295807) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.30304479598999023) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7560847997665405) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5502709448337555) { - if (maxDuration_2 <= -0.28240838646888733) { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3427748382091522) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.35559920966625214) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5373333692550659) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08361831866204739) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (averageDuration_2 <= -0.27015531063079834) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.04129335843026638) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.10523811355233192) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.886878728866577) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6377881765365601) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.24946270138025284) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.334667682647705) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5792978852987289) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.2664355933666229) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617391228675842) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.28832489252090454) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.2993554025888443) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1058686971664429) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3149110078811646) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.8518567085266113) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9142167568206787) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9355696141719818) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.21410495042800903) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.817373812198639) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (averageDuration_2 <= -0.158875972032547) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616003632545471) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1330556496977806) { - if (maxDuration_2 <= -0.260244682431221) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.08150799944996834) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6658473610877991) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5537188649177551) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.3962578624486923) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.2227640077471733) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028930187225342) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.20954284816980362) { - if (maxDuration_2 <= -0.33716002106666565) { - if (averageDuration_2 <= -0.2667088210582733) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.28964002430438995) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2987538129091263) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.01611737348139286) { - if (maxDuration_2 <= -0.2452893704175949) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3818919658660889) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.25077225267887115) { - if (maxDuration_2 <= -0.3589082509279251) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6035719513893127) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4338373839855194) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (averageDuration_2 <= -0.08623037859797478) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1699594184756279) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4276142865419388) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.34151895344257355) { - if (averageDuration_2 <= -0.2682454586029053) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4812910556793213) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (maxDuration_2 <= -0.36724843084812164) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.23690717667341232) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3890136033296585) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.690115809440613) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (averageDuration_2 <= -0.2755594551563263) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.43015794456005096) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3787899315357208) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.25005583465099335) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (averageDuration_2 <= -0.1868828982114792) { - if (averageDuration_2 <= -0.22986715286970139) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.15699046850204468) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836058139801025) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.21015457808971405) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.33441968262195587) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (maxDuration_2 <= -0.3852507770061493) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4224183559417725) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5176974833011627) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08966985088773072) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4051479548215866) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6776900589466095) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4611049890518188) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.2811780422925949) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (maxDuration_2 <= -0.38816843926906586) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.28374050557613373) { - if (maxDuration_2 <= -0.3160957545042038) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0004646275192499161) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.17073660902678967) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.2642075717449188) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.01496067875996232) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3006367087364197) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4942189007997513) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - if (averageDuration_2 <= -0.24844079464673996) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.31374046206474304) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.27477996051311493) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2228635922074318) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617244601249695) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.7505510747432709) { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3143675327301025) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9502524733543396) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461689293384552) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.14856670424342155) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8916389048099518) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5364645272493362) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185645341873) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7543280124664307) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4611098766326904) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.059363359585404396) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461599349975586) { - if (averageDuration_2 <= -0.6790809035301208) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2985755354166031) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6182836592197418) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4356045722961426) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.350590229034424) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5395924150943756) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.03074631467461586) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.6482369899749756) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.6132869720458984) { - if (maxDuration_2 <= -0.47133949398994446) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5546479970216751) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.370543122291565) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0462589859962463) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - if (averageDuration_2 <= -0.630023717880249) { - if (numDurations_2 <= 1.5776891708374023) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.4576099514961243) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 1.008537232875824) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5249413549900055) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.0028034448623657) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461667776107788) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.764528274536133) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3183400332927704) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5434842705726624) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.1580029129981995) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5377740263938904) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.1434106826782227) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.6065900325775146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.0646941661834717) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.593091070652008) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7869033813476562) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.232851505279541) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.3226674795150757) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.4576098918914795) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.736188530921936) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.31898969411849976) { - if (maxDuration_2 <= -0.6490029394626617) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7960852682590485) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 1.008537232875824) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.482079982757568) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.815155506134033) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.4758663922548294) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7877449095249176) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.6996400356292725) { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.8208415508270264) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0184154212474823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9191526770591736) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.6035412549972534) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8188257217407227) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6287179291248322) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.075559675693512) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8740872144699097) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4676833748817444) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5807949900627136) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.16108286380767822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.117706298828125) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.3997823596000671) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.2287803292274475) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8221323192119598) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.47513236105442047) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.14660311862826347) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.828829526901245) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.655461072921753) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.5665739178657532) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.4821932911872864) { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.88081955909729) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.3127616047859192) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.7139012813568115) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.35195110738277435) { - if (averageDuration_2 <= -0.61421138048172) { - if (numDurations_2 <= 0.43938523530960083) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.436114549636841) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.9290050268173218) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6879672110080719) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.622090995311737) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2738459706306458) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0971235036849976) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.2587442994117737) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4622560143470764) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.0976392030715942) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.670087605714798) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2244835495948792) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { - if (averageDuration_2 <= -0.7222028970718384) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4838865399360657) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.734078288078308) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (averageDuration_2 <= -0.6300341784954071) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.44120562076568604) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.462140679359436) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.496540606021881) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.1783012747764587) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.247114419937134) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.029591891914606094) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.5647449493408203) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.058659059926867485) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.011927980929613113) { - if (maxDuration_2 <= -0.5669639706611633) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6905273497104645) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5547195971012115) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.136928081512451) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4591410160064697) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5795921385288239) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6988271772861481) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7213721871376038) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6581415235996246) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6888639330863953) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5059231221675873) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.7111433446407318) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.1070023775100708) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8495564758777618) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0048209428787231) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5768853425979614) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.603390395641327) { - if (maxDuration_2 <= -0.49372856318950653) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8814854621887207) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1540033221244812) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1784498393535614) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.04572329297661781) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (numDurations_2 <= 3.8542970418930054) { - if (averageDuration_2 <= -0.6396484971046448) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.14397023618221283) { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.4230196475982666) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.778661012649536) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6601682603359222) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.4863998293876648) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4589807987213135) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.9363716542720795) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20123599469661713) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.09995615109801292) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { - if (averageDuration_2 <= -0.6948885321617126) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3350065350532532) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6042692065238953) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5481290519237518) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.058113276958465576) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6834675371646881) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -3.0163023471832275) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.23199841007590294) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.6384719014167786) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5362087786197662) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.407145231962204) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6544688940048218) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618250727653503) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - if (averageDuration_2 <= -0.36733441054821014) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0632526278495789) { - if (averageDuration_2 <= -0.4063328057527542) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5737687647342682) { - if (maxDuration_2 <= -0.6469311714172363) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.21543563157320023) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.7972663044929504) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.128469467163086) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.5566930770874023) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.6878583431243896) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.7091822624206543) { - if (averageDuration_2 <= -0.5650017857551575) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6085500121116638) { - if (averageDuration_2 <= -0.4131365269422531) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8982323706150055) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.593091070652008) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8271262049674988) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.17338982969522476) { - if (numDurations_2 <= 1.5776892304420471) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { - if (numDurations_2 <= -1.837222695350647) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.7930396795272827) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9737967848777771) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.806822419166565) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6704152822494507) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.31695446372032166) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.46907684206962585) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.447493553161621) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.267017900943756) { - if (averageDuration_2 <= -0.4792470335960388) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.1783012747764587) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5922571420669556) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9536126255989075) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.2385960817337036) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.2265063524246216) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7248521447181702) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.2896692752838135) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8189626932144165) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2155027389526367) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5965052843093872) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.241388201713562) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.21396403014659882) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0623801946640015) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.1686182022094727) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.5068358182907104) { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.2249561548233032) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.42461895942688) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.11029172502458096) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.6819607615470886) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.547453373670578) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.781357765197754) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5529413521289825) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0172525644302368) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.1049726009368896) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0982537865638733) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2796006202697754) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4795931577682495) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.5414674282073975) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.627035915851593) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.4670807719230652) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9341025948524475) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6163031160831451) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2304048538208008) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.002803385257721) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 0.15480925142765045) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5460585653781891) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8814854323863983) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.5877141952514648) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4636141061782837) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409679770469666) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8775232434272766) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1428144872188568) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6205661594867706) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (averageDuration_2 <= -0.5460230112075806) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - if (maxDuration_2 <= -0.5453853607177734) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.1186873316764832) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (averageDuration_2 <= -0.4898129105567932) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.5202332735061646) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.08590482175350189) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.4735721349716187) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7883439362049103) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2934679985046387) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.776781141757965) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.0674948692321777) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.2123268842697144) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.4504905343055725) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06097376253455877) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.38994139432907104) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.16669779270887375) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.461654543876648) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4495493173599243) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.2961843013763428) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.7284773588180542) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.8173737525939941) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2710488438606262) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0301701426506042) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9436168670654297) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.593091070652008) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.024668037891388) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8786739110946655) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.7221550345420837) { - if (averageDuration_2 <= -0.2954387366771698) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.1466110944747925) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.14397023618221283) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5399353504180908) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.376254677772522) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4495320320129395) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (numDurations_2 <= 0.43938523530960083) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9921256005764008) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.599594235420227) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.662456214427948) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.3412681818008423) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.2610379755496979) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4620527625083923) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8954995274543762) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13854463398456573) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.33432537317276) { - if (maxDuration_2 <= -0.3642979711294174) { - if (averageDuration_2 <= -0.3590235412120819) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.6184421181678772) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.0774097442626953) { - if (averageDuration_2 <= -0.315903440117836) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8220312893390656) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5989179015159607) { - if (maxDuration_2 <= -0.4185810983181) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0728518962860107) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.28675179183483124) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.20619340240955353) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5215759873390198) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7575733959674835) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0697360672056675) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.338785767555237) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18249281495809555) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5960299670696259) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9591535031795502) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.013704310171306133) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0181790590286255) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.2385960221290588) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11831073090434074) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { - if (maxDuration_2 <= -0.41793787479400635) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.5521375834941864) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.291418969631195) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.677155613899231) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4070816785097122) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.09995615109801292) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= -1.2680707424879074) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.310835838317871) { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0546895265579224) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9650880694389343) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.988897979259491) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.18798433244228363) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.11029172502458096) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.3510091155767441) { - if (maxDuration_2 <= -0.58884397149086) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.2812066376209259) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.29360024631023407) { - if (maxDuration_2 <= -0.6208974421024323) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0604872703552246) { - if (maxDuration_2 <= -0.3946142792701721) { - if (maxDuration_2 <= -0.41402484476566315) { - if (maxDuration_2 <= -0.594585508108139) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.3349531292915344) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.009416103363037) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.174602508544922) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.43753771483898163) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0539959073066711) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3217187076807022) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.5630825161933899) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.5096820294857025) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5899956226348877) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 1.008537232875824) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3315280079841614) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733350411057472) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (averageDuration_2 <= -0.5526518821716309) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.6188385486602783) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9372610449790955) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3551086783409119) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.462574541568756) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4592961519956589) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4602969884872437) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3955857753753662) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3573181629180908) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.0975580215454102) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4085301160812378) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1641283594071865) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.622090995311737) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 1.5776891708374023) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.6982106566429138) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5989364683628082) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616140723228455) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.8356302082538605) { - if (averageDuration_2 <= -0.5864101052284241) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2434280663728714) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5193299949169159) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0226791501045227) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.227587640285492) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5871792435646057) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3794839978218079) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (maxDuration_2 <= -0.4164966940879822) { - if (averageDuration_2 <= -0.522004246711731) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7348887622356415) { - if (averageDuration_2 <= -0.29085399210453033) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1882392168045044) { - if (maxDuration_2 <= -0.4919101446866989) { - if (maxDuration_2 <= -0.6114278733730316) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.3475484102964401) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.1466110944747925) { - if (maxDuration_2 <= -0.48160193860530853) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.930047035217285) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2156863808631897) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5434186458587646) { - if (averageDuration_2 <= -0.4295065701007843) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9016676545143127) { - if (maxDuration_2 <= -0.5218490064144135) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4128761887550354) { - if (maxDuration_2 <= -0.41016484797000885) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (maxDuration_2 <= -0.5455804169178009) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615143537521362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.2570513486862183) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4624308943748474) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4622198343276978) { - if (averageDuration_2 <= -0.5441543459892273) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5661364197731018) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6002825200557709) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.2223153710365295) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.552420973777771) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.40310265123844147) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5341393053531647) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5100797116756439) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2967599183320999) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.051593413576483727) { - if (maxDuration_2 <= -0.37025733292102814) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.4216177761554718) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4534569382667542) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (averageDuration_2 <= -0.47647401690483093) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5416989922523499) { - if (maxDuration_2 <= -0.5392942726612091) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.433924913406372) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (averageDuration_2 <= -0.4598925709724426) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5378756523132324) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5334436297416687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5778396427631378) { - if (maxDuration_2 <= -0.3563908040523529) { - if (averageDuration_2 <= -0.34592151641845703) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.390508696436882) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1409327387809753) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5355481207370758) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0528243780136108) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6451756954193115) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.7091822624206543) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.18894339352846146) { - if (averageDuration_2 <= -0.4743240475654602) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.23457122594118118) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.23541931807994843) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.7656015157699585) { - if (numDurations_2 <= 1.5776891708374023) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.1672235205769539) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.9485477209091187) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.0406333208084106) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.536476343870163) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.453783392906189) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.0718897394835949) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.46704642474651337) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.30141371488571167) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.918459951877594) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5016650259494781) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9961796998977661) { - if (maxDuration_2 <= -0.23827877640724182) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.1783012747764587) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.33432537317276) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0022448897361755) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7010758519172668) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.873420536518097) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.4400789737701416) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7907251119613647) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.373752474784851) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3103435635566711) { - if (averageDuration_2 <= -0.31825171411037445) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2143862396478653) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.45281268656253815) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4648159742355347) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5851300358772278) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6565110385417938) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0394643247127533) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6159905195236206) { - if (maxDuration_2 <= -0.2737060785293579) { - if (averageDuration_2 <= -0.22259613126516342) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.7624515891075134) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4572146087884903) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4819324612617493) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.1378546357154846) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.2948054373264313) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (numDurations_2 <= 0.43938523530960083) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.776781141757965) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.5896854400634766) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.772175431251526) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7087369561195374) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.6362186670303345) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4781585931777954) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.1537500619888306) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.38558030128479) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.2512208893895149) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.278653383255005) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.817312240600586) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1646924018859863) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.21278975158929825) { - if (averageDuration_2 <= -0.3192234933376312) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.16025777161121368) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.0459309816360474) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.552420973777771) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.2557954639196396) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4371999502182007) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0761001892387867) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5884540677070618) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.5129289031028748) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8044033050537109) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7540424168109894) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8963220119476318) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.299040973186493) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5158420503139496) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.270844578742981) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.7583757638931274) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.6220788955688477) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.479575276374817) { - if (maxDuration_2 <= -0.2639526128768921) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5332667827606201) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.956267774105072) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.20334765315055847) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.4353957921266556) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9703625440597534) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.3796340823173523) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.39341555535793304) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.48324301838874817) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.18884215503931046) { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.0929139852523804) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.21744229644536972) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618036150932312) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5401434898376465) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5708314180374146) { - if (averageDuration_2 <= -0.30747516453266144) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5343220233917236) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.036251459270715714) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.938469648361206) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5537965297698975) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.29970555007457733) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21144329756498337) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1074102520942688) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08888150006532669) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.02009203191846609) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2904207110404968) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1908849012106657) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.155260801315308) { - if (numDurations_2 <= 1.008537232875824) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7161533534526825) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2776988297700882) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2961706221103668) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.783655047416687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0003146110102534294) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.2610563039779663) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.42336505651474) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.425079345703125) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.44124336540699005) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618817567825317) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.084824323654175) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1618068590760231) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6044227778911591) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0994303822517395) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4339929223060608) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2051321193575859) { - if (numDurations_2 <= 0.7239612340927124) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.253804087638855) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5954073369503021) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0179649889469147) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5189965069293976) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.207022488117218) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1508383750915527) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.8154819309711456) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.020112778060138226) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.19452083110809326) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4622540473937988) { - if (averageDuration_2 <= -0.10456223785877228) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (averageDuration_2 <= -0.4364365488290787) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.6214135885238647) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.664660930633545) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - if (maxDuration_2 <= -0.30202920734882355) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6746354103088379) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.23188431560993195) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.15736816078424454) { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.27386142313480377) { - if (maxDuration_2 <= -0.2016003206372261) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6774446964263916) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.20290211588144302) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.656916618347168) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15490391850471497) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1978471651673317) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6546749770641327) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22014809399843216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4478986859321594) { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.0572593212127686) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.9290050268173218) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.03425528120715171) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2082081437110901) { - if (averageDuration_2 <= -0.6501690447330475) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - if (averageDuration_2 <= -0.3586532920598984) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.3385978937149048) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7411036491394043) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.43551841378211975) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1919825673103333) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (numDurations_2 <= 0.15480925142765045) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.17117217928171158) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.41903918981552124) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.6482369899749756) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.806822419166565) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5999326407909393) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.754804491996765) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4961591511964798) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.749491214752197) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 1.008537232875824) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.9084832668304443) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.039053201675415) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0769430994987488) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3936315774917603) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - if (numDurations_2 <= 1.5776891708374023) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6946036219596863) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.722473919391632) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6924784481525421) { - if (averageDuration_2 <= -0.5233922898769379) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.24241863191127777) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.4929831027984619) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3629505038261414) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.043676257133484) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22071382403373718) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.15541428700089455) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.6321735382080078) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6621103584766388) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.8782627880573273) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.014200667850673199) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186675310135) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.14385507255792618) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9070866107940674) { - if (averageDuration_2 <= -0.5508539974689484) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.18452221155166626) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.3349531292915344) { - if (averageDuration_2 <= -0.6990936994552612) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.18992957472801208) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.612455278635025) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2503615617752075) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283403396606) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.687044084072113) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.029591891914606094) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5116496682167053) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.40309110283851624) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2047903537750244) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3894266039133072) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.6982106566429138) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.588131844997406) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9123512208461761) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.33969521522522) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18692556023597717) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.779147744178772) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.662408858537674) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4443460702896118) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.540958046913147) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.44751420617103577) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.33948375284671783) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.0244272351264954) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.2663294672966003) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (averageDuration_2 <= -0.4708472192287445) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4625998735427856) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4607952237129211) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06234296225011349) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.210874319076538) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.07546784356236458) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (averageDuration_2 <= -0.5421642959117889) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.970554769039154) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - if (averageDuration_2 <= -0.6110625863075256) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4393004179000854) { - if (maxDuration_2 <= -0.04860787279903889) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461968719959259) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.05959477461874485) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3946945071220398) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1473565101623535) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.038375627249479294) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614478945732117) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.1516360640525818) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.235006034374237) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.13450168073177338) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1424911804497242) { - if (averageDuration_2 <= -0.5096052289009094) { - if (maxDuration_2 <= -0.05360988527536392) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617840647697449) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1634882539510727) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.9565199613571167) { - if (numDurations_2 <= 3.8542970418930054) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.435526967048645) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2505820319056511) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6546749770641327) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.147408366203308) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.42821289598941803) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.05540861934423447) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - if (averageDuration_2 <= -0.2046155408024788) { - if (numDurations_2 <= -0.9834946841001511) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.06105615384876728) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404551506042) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.49558527767658234) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9102784395217896) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2561350241303444) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.17996849864721298) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0696946233510971) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.0044367047958076) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.17812837660312653) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.018788951449096203) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.22289925068616867) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3416653722524643) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.2688431888818741) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17916389554738998) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 1.5776891708374023) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.09785144776105881) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6598781645298004) { - if (maxDuration_2 <= -0.0851825661957264) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.32002659142017365) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.20268184691667557) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.11857046186923981) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0064657945185899734) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.1221967302262783) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.33134444057941437) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.3699389696121216) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6446018517017365) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.15442707389593124) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.05594206601381302) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1394532173871994) { - if (maxDuration_2 <= -0.10878480970859528) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (averageDuration_2 <= -0.27785876393318176) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9246130585670471) { - if (numDurations_2 <= 2.4314171075820923) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.09330239146947861) { - if (maxDuration_2 <= -0.13671272993087769) { - if (maxDuration_2 <= -0.19156313687562943) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.07322755828499794) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.794999748468399) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0311720967292786) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.17337137460708618) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (maxDuration_2 <= -0.12936021387577057) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1151999868452549) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158463835716) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.9293405413627625) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.18430721014738083) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.22068984806537628) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9554441869258881) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.17073660343885422) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2045757919549942) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.9596757888793945) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618280529975891) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.1706356182694435) { - if (averageDuration_2 <= -0.2210707738995552) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.02921954169869423) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.45621731877326965) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.31720077246427536) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2509564235806465) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.053344935178756714) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.2184414863586426) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5425611734390259) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.1741737201809883) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.21549149602651596) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.18309377878904343) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (maxDuration_2 <= -0.04318040609359741) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11910314485430717) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.033245230093598366) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2758517563343048) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6139990389347076) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.728360652923584) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.460382878780365) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (maxDuration_2 <= -0.09987467154860497) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2735671252012253) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619032740592957) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5351896584033966) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12526218220591545) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (maxDuration_2 <= -0.039100171998143196) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1507693976163864) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12330761551856995) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6102865934371948) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1994336247444153) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.0243672132492065) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06416112743318081) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.3693881034851074) { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.322673797607422) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - if (averageDuration_2 <= -0.11060895398259163) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.7221550345420837) { - if (maxDuration_2 <= -0.04581689462065697) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7598154544830322) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.300660490989685) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.19578275829553604) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4357921481132507) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5138912498950958) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.33937326073646545) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2702780961990356) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.5074199438095093) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.48421627283096313) { - if (averageDuration_2 <= -0.14667648822069168) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.266273260116577) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.702393352985382) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2403922602534294) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.01612796261906624) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4440556168556213) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6462755799293518) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.27955952286720276) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.324747085571289) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.16055136919021606) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5688589513301849) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.3677852749824524) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.8376701474189758) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2353584170341492) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.23222923278808594) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.2265063524246216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1538746356964111) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.27607475221157074) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.5304139256477356) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.8274345993995667) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.5068358182907104) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8963220119476318) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.5566930770874023) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9410592317581177) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5212291181087494) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (maxDuration_2 <= -0.14984982460737228) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4787360429763794) { - if (averageDuration_2 <= -0.2949259430170059) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1707926988601685) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.004849503166042268) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.5079383850097656) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.15910989791154861) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.7504844069480896) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8457118272781372) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1977542638778687) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5372855067253113) { - if (maxDuration_2 <= -0.1965552121400833) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4368640184402466) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - if (maxDuration_2 <= -0.18683473765850067) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3103435635566711) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.3425183594226837) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.193001851439476) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.619449108839035) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.45273467898368835) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.26229962706565857) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.07161573693156242) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.11622961238026619) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1029167175292969) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.04465924948453903) { - if (averageDuration_2 <= -0.2471022829413414) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2178308367729187) { - if (averageDuration_2 <= -0.12506618350744247) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132515907288) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.08804169669747353) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.3141508251428604) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13318386673927307) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.4670807719230652) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5255667567253113) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.2911977767944336) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.009483803994953632) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 1.5776891708374023) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (averageDuration_2 <= -0.17262369394302368) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.2566463351249695) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.09995615109801292) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9358725249767303) { - if (averageDuration_2 <= 0.020998301450163126) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.608759045600891) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.444513738155365) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.15842972695827484) { - if (averageDuration_2 <= -0.410697340965271) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.218268733471632) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5689411759376526) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.34296341240406036) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7494911849498749) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (numDurations_2 <= -0.4143427312374115) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.067669153213501) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.706470251083374) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.016964852809906) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4464487433433533) { - if (averageDuration_2 <= -0.10593142360448837) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.03388035669922829) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (averageDuration_2 <= -0.2858690619468689) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.8948506116867065) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (maxDuration_2 <= -0.13485624641180038) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7385323941707611) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -3.1672489643096924) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.6651921272277832) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (numDurations_2 <= 1.2931131720542908) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06535936146974564) { - if (maxDuration_2 <= -0.16747980564832687) { - if (averageDuration_2 <= -0.2794599086046219) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22159111499786377) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.16885486990213394) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.8165296912193298) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0543877482414246) { - if (maxDuration_2 <= -0.1991056501865387) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.29332125186920166) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6362839341163635) { - if (averageDuration_2 <= -0.16354993730783463) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0745406746864319) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.10308492183685303) { - if (maxDuration_2 <= -0.12798507511615753) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4472690224647522) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6539501249790192) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.3693881034851074) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.6404491662979126) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.26639652252197266) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6262789368629456) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.8605195879936218) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.6482369899749756) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.736188530921936) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.8452296257019043) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.970554769039154) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.8689790964126587) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0984068512916565) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3638110160827637) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1116220355033875) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5784355998039246) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5798149406909943) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3220828175544739) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618543982505798) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (averageDuration_2 <= 0.013600532314740121) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4483657479286194) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.1572839766740799) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= 1.5776891708374023) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.979005753993988) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.942109614610672) { - if (averageDuration_2 <= -0.22711119800806046) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (averageDuration_2 <= 0.06667913729324937) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2684716433286667) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.04431183263659477) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - if (maxDuration_2 <= -0.08158867433667183) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4546797275543213) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5424005389213562) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6826821863651276) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.1426982283592224) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.1676570400595665) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.286486804485321) { - if (maxDuration_2 <= -0.11327513679862022) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1401420310139656) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701517701148987) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5186909139156342) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5394555926322937) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.091856598854065) { - if (maxDuration_2 <= -0.1547556295990944) { - if (averageDuration_2 <= -0.23951540887355804) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2203974947333336) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6790664792060852) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.023918727412819862) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6171450018882751) { - if (maxDuration_2 <= -0.16755080223083496) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.15753469616174698) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2561320783570409) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2521565333008766) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.21396403014659882) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.17720988392829895) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0050434538861736655) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.2202489823102951) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.7791004180908203) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0965296626091003) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.03288457542657852) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (maxDuration_2 <= -0.07590781524777412) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06491485424339771) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.046052319929003716) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319651782512665) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.01946221012622118) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5225109457969666) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.024487389251589775) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.452807605266571) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.726328134536743) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.026483568362891674) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.45812590420246124) { - if (maxDuration_2 <= -0.13989119976758957) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.09470810368657112) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.1425129994750023) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.728938341140747) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7261990308761597) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5251364707946777) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4869908541440964) { - if (maxDuration_2 <= -0.10350657999515533) { - if (averageDuration_2 <= -0.11741504818201065) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.20367415249347687) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461692214012146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.13433124125003815) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.6979585886001587) { - if (averageDuration_2 <= -0.10399672016501427) { - if (averageDuration_2 <= -0.10675084218382835) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.33103421330451965) { - if (averageDuration_2 <= -0.24421410262584686) { - if (maxDuration_2 <= -0.13074064254760742) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.04020356200635433) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.606417253613472) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7952302098274231) { - if (averageDuration_2 <= -0.13143712282180786) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.1832028329372406) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.371296465396881) { - if (averageDuration_2 <= -0.4605397582054138) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0462589859962463) { - if (maxDuration_2 <= -0.44269220530986786) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9203162789344788) { - if (numDurations_2 <= 1.5776891708374023) { - if (averageDuration_2 <= -0.6517173647880554) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.960754632949829) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5152103006839752) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.2005058825016022) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4014349430799484) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5387052446603775) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.4205806255340576) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.4985998421907425) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.549740791320801) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.5811039209365845) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.760370969772339) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.3183590173721313) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6601145267486572) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { - if (averageDuration_2 <= -0.5148124992847443) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.2152851819992065) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.9333924055099487) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.4205806255340576) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.12116014957428) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.490656018257141) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.876897096633911) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.910454034805298) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.5454479157924652) { - if (maxDuration_2 <= -0.7194193303585052) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.46201013028621674) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.4643564224243164) { - if (averageDuration_2 <= -0.7157584726810455) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.754804491996765) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4639714360237122) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.170398235321045) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9174076318740845) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.622730255126953) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.8302929401397705) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.4869600981473923) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 6.407958030700684) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0442404747009277) { - if (averageDuration_2 <= -0.5535960495471954) { - if (cpuCoreIdleTimesPercentage_4_2 <= -5.143476486206055) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 5.83650541305542) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.094433307647705) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.2380990982055664) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3103435039520264) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5729290843009949) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5342059135437012) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.5068358182907104) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.2569116353988647) { - if (maxDuration_2 <= -0.3581080287694931) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.3613630533218384) { - if (averageDuration_2 <= -0.6947090327739716) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3365737274289131) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.815155506134033) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2325400114059448) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1267486810684204) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.399016797542572) { - if (maxDuration_2 <= -0.10531997680664062) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -4.235919117927551) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9742395877838135) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.7511109113693237) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.090091347694397) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.599594235420227) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 4.56823468208313) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.09443336725235) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.8910906314849854) { - if (maxDuration_2 <= -0.3255122900009155) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.12016559392213821) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.6672534942626953) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1220508217811584) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.373752474784851) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4958640784025192) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.3800418376922607) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3180382549762726) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { - if (maxDuration_2 <= -0.6840453147888184) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7416684925556183) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.7930396795272827) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.5697202682495117) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5325501263141632) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.08606896921992302) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.2556352764368057) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.9162233769893646) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.518887460231781) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6721392571926117) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.6982201635837555) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 5.53657865524292) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.051715970039368) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781625390052795) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5142332315444946) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9387838542461395) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.0055207312107086) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 6.081448554992676) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.3796340823173523) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.9162233769893646) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8261885643005371) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089243412018) { - if (numDurations_2 <= 1.5776891708374023) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.42197048664093) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6517821550369263) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.0446120500564575) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7699747681617737) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.20130643993616104) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.32874099910259247) { - if (maxDuration_2 <= -0.5445268452167511) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 6.492292881011963) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 5.416452884674072) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7556182742118835) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.128469467163086) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.1833787560462952) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.6263859272003174) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.92511522769928) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6666365265846252) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { - if (averageDuration_2 <= -0.6731269657611847) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.6988641023635864) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6708867847919464) { - if (averageDuration_2 <= -0.6948378682136536) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.7274783849716187) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0611408948898315) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7543061971664429) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.5192242860794067) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4736960232257843) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.0026832818984985) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.200182020664215) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.075559675693512) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349805697799) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.9953777194023132) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9526275098323822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.077729225158691) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6850890815258026) { - if (maxDuration_2 <= -0.7283901274204254) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.17708710581064224) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3357419818639755) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15564509481191635) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.5193292051553726) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 1.5776891708374023) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.151379346847534) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3863663822412491) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5888849198818207) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.373752474784851) { - if (averageDuration_2 <= -0.5159313976764679) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.844688057899475) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4292654991149902) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3442365527153015) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.7154715061187744) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.35311898589134216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9585451483726501) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5226146280765533) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - if (averageDuration_2 <= -0.6840804517269135) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5678756535053253) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3066815733909607) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.0718897394835949) { - if (averageDuration_2 <= -0.6736148595809937) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8128155767917633) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.3302619457244873) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.7064703106880188) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6578723192214966) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6071547269821167) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.2110661268234253) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.9290050268173218) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7555900812149048) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1384708285331726) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7253622710704803) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5954254865646362) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.419930636882782) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5992175340652466) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8498036861419678) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.1043844074010849) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.04252827167511) { - if (averageDuration_2 <= -0.5646933019161224) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.1247397661209106) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.007515541277825832) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.011162791401147842) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5301892459392548) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7070369124412537) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -4.193760514259338) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.21798385679721832) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3783380091190338) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093146696686745) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1158908903598785) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2606525421142578) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8772926330566406) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4768738746643066) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (maxDuration_2 <= -0.45229367911815643) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6542955935001373) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (averageDuration_2 <= -0.7164859175682068) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.2880917489528656) { - if (numDurations_2 <= 3.8542970418930054) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8938599228858948) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6401868760585785) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.31303733587265015) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.773085743188858) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.3677852749824524) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8479446172714233) { - if (averageDuration_2 <= -0.5629481375217438) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.9985268115997314) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5163151621818542) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.6624360680580139) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.315594434738159) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.069137811660767) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.91882586479187) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1493337154388428) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.5964350700378418) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7126517593860626) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5141507685184479) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6946036517620087) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 6.526206016540527) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 5.730664491653442) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 5.100101709365845) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.40310265123844147) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.55797278881073) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.04611337184906) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.332209289073944) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.447756290435791) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.9135369062423706) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.084824323654175) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6950976550579071) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5387052446603775) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.6144105195999146) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8223898410797119) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.308491945266724) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.19341379404068) { - if (maxDuration_2 <= -0.6772676706314087) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.6744437217712402) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.45751993358135223) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4846593141555786) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.0900914072990417) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404551506042) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.159201204776764) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2479664087295532) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.2315618991851807) { - if (averageDuration_2 <= -0.592371016740799) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.484916925430298) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.07104289624840021) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.002244919538498) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1646387577056885) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.0132548809051514) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9981546401977539) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.6419752240180969) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3260877653956413) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -6.3989098072052) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0022448897361755) { - if (maxDuration_2 <= -0.6203606724739075) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3452826142311096) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.3800418376922607) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.976557970046997) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.21396403014659882) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.057259261608124) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7213721573352814) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.5784499645233154) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -5.964418172836304) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.4512444734573364) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.549441695213318) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.454709768295288) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.4105457067489624) { - if (averageDuration_2 <= -0.30036094784736633) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.8782627582550049) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 0.3138919323682785) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.281707301735878) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.1783012747764587) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.002405945211648941) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7448217272758484) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.736188530921936) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.3876566141843796) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.0042311549186707) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.70000422000885) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.1537500619888306) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8482733368873596) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.18438546359539032) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.9290050268173218) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.21996235102415085) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.721589595079422) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.16545112431049347) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.9485477805137634) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -5.2091405391693115) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuCoreIdleTimesPercentage_5_2 <= -5.165159225463867) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.012774040456861258) { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.092849254608154) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.876897096633911) { - if (maxDuration_2 <= -0.12673895433545113) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.45751993358135223) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3103435635566711) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0903413891792297) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3176172971725464) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.876897096633911) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.735241025686264) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.27142536640167236) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.7972663044929504) { - if (maxDuration_2 <= -0.18253431469202042) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 0.015712805092334747) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.48409511148929596) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.56138277053833) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.338785767555237) { - if (averageDuration_2 <= 0.03280335571616888) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.631614089012146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.2961843013763428) { - if (averageDuration_2 <= -0.2845531553030014) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.49292998015880585) { - if (averageDuration_2 <= -0.31117549538612366) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.844688057899475) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.011063045356422663) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1881467029452324) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.4824860244989395) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4575536549091339) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5354723632335663) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.3064555525779724) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.30675648152828217) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718024134635925) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.094433307647705) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.43490731716156) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.21951200813055038) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 0.15587187558412552) { - if (maxDuration_2 <= -0.205163836479187) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0972643792629242) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.34018470346927643) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368339061737) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.128074884414673) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.36861181259155273) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.772175431251526) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= 0.07179300859570503) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.40125027298927307) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (maxDuration_2 <= -0.31105560064315796) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014949262142181) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.2166862040758133) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.102656841278076) { - if (averageDuration_2 <= -0.40940138697624207) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.181956171989441) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.8564924001693726) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.7289382815361023) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.7752944231033325) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.142114996910095) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5503549575805664) { - if (maxDuration_2 <= -0.43792326748371124) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5470973551273346) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.844688057899475) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.326260566711426) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.44955162703990936) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.4576098918914795) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.5414674282073975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9792207479476929) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.07104289624840021) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.34638895094394684) { - if (maxDuration_2 <= -0.2779937833547592) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0917135737836361) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6401693522930145) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7406724989414215) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22546830773353577) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8071976900100708) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8755281567573547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.771754503250122) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2710198760032654) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5110293626785278) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.30548790097236633) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.14300143718719482) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.120387554168701) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8223898708820343) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1238964796066284) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6546749770641327) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.03948767390102148) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1434461697936058) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.15357730910182) { - if (maxDuration_2 <= -0.28900593519210815) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.1865309774875641) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.454709768295288) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.754804491996765) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3092341423034668) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.29295703768730164) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.981550097465515) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.4064040184020996) { - if (averageDuration_2 <= -0.38568927347660065) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.0976392030715942) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.128469467163086) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4030160754919052) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6033900082111359) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.4412788599729538) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.6415618658065796) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.6451467275619507) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 0.7239612340927124) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5055821239948273) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3103435635566711) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.02385823894292116) { - if (maxDuration_2 <= -0.5010809302330017) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.8385125398635864) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.1475950479507446) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2898950576782227) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.3226674795150757) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.2662731409072876) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2304881811141968) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6220910549163818) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.8605195879936218) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.9523173570632935) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5311709344387054) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0529807209968567) { - if (maxDuration_2 <= -0.45073102414608) { - if (averageDuration_2 <= -0.3758976310491562) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089243412018) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.4863998293876648) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514857307076) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.415175676345825) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.7469977140426636) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.1025970578193665) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5545837879180908) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.9968165159225464) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9601624608039856) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.431552529335022) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.2521325498819351) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.5927202701568604) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1646878719329834) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8188689947128296) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.2449105903506279) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.2541909217834473) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.059758722782135) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3983716368675232) { - if (averageDuration_2 <= -0.4046422392129898) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (numDurations_2 <= 1.5776891708374023) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.5964350700378418) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 0.43938523530960083) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.6338953971862793) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.7900195121765137) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.17592425644397736) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.21280329674482346) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.3410741090774536) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.319189190864563) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7740775346755981) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 5.846328973770142) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.35295209288597107) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.9587630033493042) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.8430447578430176) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.4978281259536743) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.5414674282073975) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.664973020553589) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.4340795278549194) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.407717943191528) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.5098878145217896) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.8759267926216125) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5364645272493362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 6.435187578201294) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (maxDuration_2 <= -0.03313572145998478) { - if (averageDuration_2 <= -0.4365865886211395) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.0224738121032715) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8331891894340515) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.2084840536117554) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5795921385288239) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.7510048151016235) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.19696440547704697) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.3217923939228058) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2660680264234543) { - if (maxDuration_2 <= -0.16755583882331848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7206164300441742) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 5.021750450134277) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.3639936447143555) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.938991367816925) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236781001091003) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.016964852809906) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.5558815002441406) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.239214777946472) { - if (maxDuration_2 <= -0.4751918315887451) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.0976392030715942) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.451817810535431) { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.537806510925293) { - if (numDurations_2 <= 1.008537232875824) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.3491384983062744) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.4990852028131485) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.0042311549186707) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.7930396795272827) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.41827137768268585) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.5911834239959717) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.9434726238250732) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4114603996276855) { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.716659069061279) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.1149210929870605) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.486834526062012) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.13689523935318) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1209300756454468) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.6307660341262817) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.8949843645095825) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.273658275604248) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2674176692962646) { - if (averageDuration_2 <= -0.6852892637252808) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.09687595441937447) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 6.546828269958496) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.5074199438095093) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (numDurations_2 <= -1.837222695350647) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (averageDuration_2 <= -0.37771689891815186) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { - if (maxDuration_2 <= -0.7618089616298676) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.257839322090149) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.2730184718966484) { - if (cpuCoreIdleTimesPercentage_0_2 <= -3.1456851959228516) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4609603881835938) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.445444941520691) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4729609787464142) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9475547671318054) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.5566930770874023) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6206668957784132) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.702006757259369) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.4923457056283951) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 4.078429937362671) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.6321735382080078) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5900544226169586) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.703396797180176) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.33432537317276) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.9812396168708801) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.859567403793335) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5968583822250366) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8211257457733154) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.8173737525939941) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 6.16935396194458) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.4263787269592285) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613677859306335) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.3693881034851074) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5400769114494324) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.6010546684265137) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.08607661351561546) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.2222009897232056) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.9104539155960083) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.8759267926216125) { - if (averageDuration_2 <= -0.7136699855327606) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454916000366) { - if (averageDuration_2 <= -0.2793477922677994) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.9084832668304443) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6948850154876709) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597728431224823) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.5824715495109558) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.31720077246427536) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.5392308235168457) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.09964840486645699) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.0243672728538513) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4610952138900757) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.0674948692321777) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.411447286605835) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.044527769088745) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612740278244019) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.28065918385982513) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.077553749084473) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.802748203277588) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.9713491201400757) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.27393679320812225) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 6.656718969345093) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.3124085664749146) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.2663294672966003) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.8431501388549805) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.089825987815857) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6608555614948273) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.1272987127304077) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.280956506729126) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 4.552486181259155) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.6939990222454071) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.334265947341919) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.7878230810165405) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.8948506116867065) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.215251207351685) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.381303310394287) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (maxDuration_2 <= -0.39912496507167816) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.4812127351760864) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.251320123672485) { - if (averageDuration_2 <= -0.49606817960739136) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614977836608887) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.959371268749237) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.474029779434204) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.11270809173584) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.1272987127304077) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.233586072921753) { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.334991455078125) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.1466110944747925) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.028396189212799) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753037750720978) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6542955935001373) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6529807150363922) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (averageDuration_2 <= -0.36843787133693695) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0804295539855957) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.34107664227485657) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.40805475413799286) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.03974040225148201) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.235338807106018) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615808129310608) { - if (maxDuration_2 <= -0.6111871302127838) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9910715818405151) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3926750421524048) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.4416525363922119) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.5068358182907104) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.4003682136535645) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617410898208618) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.4562341868877411) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.688767433166504) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6401868760585785) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 6.366624116897583) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.3226674795150757) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.304189920425415) { - if (averageDuration_2 <= -0.5895276665687561) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.1703981161117554) { - if (averageDuration_2 <= -0.6324915885925293) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6017815172672272) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1733288764953613) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.972083568572998) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.121818780899048) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.350590229034424) { - if (numDurations_2 <= 3.8542970418930054) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 5.240534543991089) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.348293781280518) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.582572817802429) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.289841890335083) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.3387858867645264) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.2961843013763428) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5688201189041138) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.7946025133132935) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 5.647507429122925) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1154991388320923) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.0093899965286255) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7367648184299469) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744439005851746) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454916000366) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.7139012813568115) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7822611629962921) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.805253267288208) { - if (maxDuration_2 <= -0.43624162673950195) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.15319287776947) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4251141548156738) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.192003607749939) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.0188469886779785) { - if (averageDuration_2 <= -0.5105845332145691) { - if (averageDuration_2 <= -0.5142288208007812) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0730392932891846) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0757912397384644) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.0890586376190186) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.486926555633545) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7952302098274231) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.336419701576233) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.04193134419620037) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4297670722007751) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.1272987127304077) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.027143120765686) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.3659674823284149) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.663274109363556) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.451099693775177) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.07488466426730156) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1578196287155151) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 4.405145883560181) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5362565517425537) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1392745077610016) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.277600035071373) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.14361479878425598) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.44641438126564026) { - if (averageDuration_2 <= -0.6040846407413483) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5948984920978546) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.36672458052635193) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.237127423286438) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.359202042222023) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.4467395842075348) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2731478065252304) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484863996505737) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5507397055625916) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.26305386424064636) { - if (averageDuration_2 <= -0.1997433751821518) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3049436956644058) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (maxDuration_2 <= -0.3425394892692566) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.34588588774204254) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.34553655982017517) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11485902220010757) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.40020838379859924) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5649442076683044) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (averageDuration_2 <= -0.2789972871541977) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6848884522914886) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.3239813446998596) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06743620336055756) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1201142780482769) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.2310083657503128) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6346502304077148) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.2902824878692627) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (maxDuration_2 <= -0.3351137191057205) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.19573838263750076) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999137312173843) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.28740212321281433) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5079361349344254) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.26567794382572174) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.44986334443092346) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5298140048980713) { - if (maxDuration_2 <= -0.4574047029018402) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5197491645812988) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3605836182832718) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (maxDuration_2 <= -0.27532942593097687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643943786621) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.4354717582464218) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5140326768159866) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2920520603656769) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (maxDuration_2 <= -0.13024671375751495) { - if (averageDuration_2 <= -0.32367953658103943) { - if (numDurations_2 <= 2.7159931659698486) { - if (maxDuration_2 <= -0.41343969106674194) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5598048865795135) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4035778045654297) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.022884486243128777) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 0.15480925142765045) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6143312454223633) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.4466603696346283) { - if (averageDuration_2 <= -0.5115528404712677) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.288336455821991) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.33150455355644226) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2501402571797371) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.25492869317531586) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (averageDuration_2 <= -0.5224162340164185) { - if (maxDuration_2 <= -0.4338708519935608) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8247130513191223) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.399388924241066) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.0976390838623047) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0889461040496826) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5746717751026154) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5760852098464966) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.7187942266464233) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.7374191284179688) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.5562760233879089) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.04803532920777798) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41536471247673035) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5071395933628082) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6510039567947388) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1250063180923462) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.15363410115242004) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3508547991514206) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.463708221912384) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.22302676737308502) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.092854619026184) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6198905408382416) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26850663125514984) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.626916289329529) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - if (averageDuration_2 <= -0.38058747351169586) { - if (maxDuration_2 <= -0.5392992794513702) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (maxDuration_2 <= -0.15295980870723724) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7629000246524811) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6383083462715149) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - if (maxDuration_2 <= -0.21893391013145447) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4620410799980164) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.26024943590164185) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (averageDuration_2 <= -0.05697101540863514) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485337555408478) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.27534346282482147) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.3038221597671509) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.300806924700737) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.17293252050876617) { - if (maxDuration_2 <= -0.2942740172147751) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.45751993358135223) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4123512953519821) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.15119710564613342) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.33534999191761017) { - if (averageDuration_2 <= -0.2509738355875015) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613766074180603) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.24105703085660934) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6421031355857849) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4202617257833481) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.2922681123018265) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5026886910200119) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6281251758337021) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.29633864760398865) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (averageDuration_2 <= -0.06885091215372086) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2608128637075424) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.05748083256185055) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.2335527539253235) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.2094939425587654) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5184737741947174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (maxDuration_2 <= -0.24190295487642288) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.060835327953100204) { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.03012752439826727) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8540283441543579) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5400970131158829) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.3624744117259979) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.1686182022094727) { - if (maxDuration_2 <= -0.3594832420349121) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.06849193200469017) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.3446215093135834) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486036121845245) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.22750668972730637) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618065357208252) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3731321543455124) { - if (maxDuration_2 <= -0.4179935157299042) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.18186046183109283) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5457851588726044) { - if (averageDuration_2 <= -0.3267345726490021) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4169272929430008) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.15378113090991974) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.19119910150766373) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4337121397256851) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.12234972789883614) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.45772960782051086) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.12936146557331085) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1380874589085579) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (averageDuration_2 <= 0.09028109908103943) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 0.01222249073907733) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.45751993358135223) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.08697061613202095) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7521025836467743) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.06711684539914131) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (maxDuration_2 <= -0.03058780450373888) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4629340767860413) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6809765100479126) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.11156419664621353) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.43737851083278656) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.27643708884716034) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (averageDuration_2 <= -0.03691084869205952) { - if (maxDuration_2 <= -0.07142750918865204) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.4114472270011902) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.170151710510254) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (maxDuration_2 <= -0.06224141828715801) { - if (averageDuration_2 <= -0.04430600255727768) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.28466878831386566) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.031003235839307308) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.1463925912976265) { - if (averageDuration_2 <= -0.27392497658729553) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.350170373916626) { - if (averageDuration_2 <= -0.39635835587978363) { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6690318286418915) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5896690785884857) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.29930347204208374) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - if (averageDuration_2 <= -0.6216040551662445) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.35607700049877167) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.25773589313030243) { - if (averageDuration_2 <= -0.6397430002689362) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.05284426733851433) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (averageDuration_2 <= -0.6133953630924225) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536155462265) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (averageDuration_2 <= -0.4532563239336014) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.31374046206474304) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.25455667078495026) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.23341833800077438) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32813143730163574) { - if (maxDuration_2 <= -0.4856392592191696) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.130440017208457) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.27907538414001465) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.181272566318512) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5358547270298004) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2025156244635582) { - if (averageDuration_2 <= -0.6169167459011078) { - if (maxDuration_2 <= -0.5921514928340912) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7089749872684479) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.44399408996105194) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5839044451713562) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.982878804206848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.558965653181076) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.48913243412971497) { - if (maxDuration_2 <= -0.4559232145547867) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.33375950157642365) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5292666554450989) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13445447385311127) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.36075545847415924) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4048230648040771) { - if (maxDuration_2 <= -0.46547138690948486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2319604605436325) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.6050042808055878) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.7284772992134094) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485196888446808) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6535642147064209) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612398147583008) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7121440172195435) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4057985544204712) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.46311376988887787) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.03723842836916447) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6164225041866302) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5786024034023285) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3218132108449936) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.276781290769577) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.30795322358608246) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.14219794422388077) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.2278490737080574) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.19381573051214218) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.06622279807925224) { - if (averageDuration_2 <= 0.2189711108803749) { - if (averageDuration_2 <= -0.026429740712046623) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2563336193561554) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3646692931652069) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486138939857483) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32861311733722687) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.10053576901555061) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09869623556733131) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21961239725351334) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5880689024925232) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.09018248692154884) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.14417143911123276) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4086911827325821) { - if (averageDuration_2 <= -0.4813312441110611) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.075559675693512) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4609525203704834) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21144767105579376) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.23500120639801025) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2153882384300232) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.342326283454895) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5708175152540207) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4657622128725052) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5062268972396851) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5952821969985962) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.595462292432785) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964074045419693) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6761052310466766) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.16504602879285812) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (averageDuration_2 <= -0.18546003848314285) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.07018454745411873) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485066950321198) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485416233539581) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.44629061222076416) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -3.2319403886795044) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613297581672668) { - if (maxDuration_2 <= -0.43443578481674194) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.2868582606315613) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5971544981002808) { - if (maxDuration_2 <= -0.17822104692459106) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.42309097945690155) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.11867078393697739) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.14972440898418427) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5740453004837036) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.18494271486997604) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.546473354101181) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1169698238372803) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.46102549135684967) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5677633583545685) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.28862954676151276) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4645984172821045) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1986772045493126) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.217516228556633) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2437117099761963) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3111402243375778) { - if (maxDuration_2 <= -0.49808740615844727) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5546018779277802) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.09712500497698784) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485787272453308) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (averageDuration_2 <= -0.27443087100982666) { - if (maxDuration_2 <= -0.3913673758506775) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.4503106027841568) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3021524250507355) { - if (averageDuration_2 <= -0.40916503965854645) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= -0.9834946841001511) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6431629955768585) { - if (averageDuration_2 <= -0.21236743032932281) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (averageDuration_2 <= -0.1248534768819809) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.5805456340312958) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22568033635616302) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.4869600981473923) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.23806851357221603) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.3782074600458145) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.026337006129324436) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.27217674255371094) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (maxDuration_2 <= -0.2052270621061325) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21287938952445984) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5354227125644684) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4280156046152115) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.025454211980104446) { - if (averageDuration_2 <= -0.6227698624134064) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2506163492798805) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6227197349071503) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485627233982086) { - if (maxDuration_2 <= -0.3786582052707672) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - if (maxDuration_2 <= -0.5407049357891083) { - if (averageDuration_2 <= -0.5425100028514862) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.47841085493564606) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6033284664154053) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (maxDuration_2 <= -0.3092244118452072) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1354902684688568) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.49435923993587494) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13199259340763092) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (averageDuration_2 <= -0.4062149226665497) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.0243672132492065) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.016184553503990173) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.27780647575855255) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3298847675323486) { - if (averageDuration_2 <= -0.5741041898727417) { - if (maxDuration_2 <= -0.5356573462486267) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17572815716266632) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3065217733383179) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (averageDuration_2 <= -0.7066989839076996) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.5495784282684326) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.025656044483184814) { - if (averageDuration_2 <= -0.053291065618395805) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.3013905733823776) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.13223453983664513) { - if (averageDuration_2 <= -0.021355340257287025) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.20365672558546066) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11071574315428734) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616687893867493) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485424280166626) { - if (maxDuration_2 <= -0.35018572211265564) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4453241229057312) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0336318789049983) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.2726322412490845) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05464697815477848) { - if (maxDuration_2 <= -0.4395771324634552) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26393668353557587) { - if (maxDuration_2 <= -0.290806844830513) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2822015732526779) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6225183606147766) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6893267929553986) { - if (averageDuration_2 <= -0.16600551456212997) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617733359336853) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - if (maxDuration_2 <= -0.18823019415140152) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.13044001534581184) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.19589168578386307) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (averageDuration_2 <= -0.2400091215968132) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.2258623242378235) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.10516176000237465) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.36535976827144623) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484157085418701) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.446844458580017) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (averageDuration_2 <= -0.5901563763618469) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.26641348004341125) { - if (maxDuration_2 <= -0.4465293288230896) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.03450704365968704) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.03806346654891968) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5838076174259186) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3047941029071808) { - if (maxDuration_2 <= -0.30740611255168915) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5141507685184479) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7431910932064056) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.11029172502458096) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.0545014007948339) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.1004982627928257) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.48742975294589996) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616023302078247) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606166541576) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.07682698452845216) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4611656069755554) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.12076423317193985) { - if (maxDuration_2 <= -0.2923644632101059) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.8303110599517822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.014578585978597403) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.41785159707069397) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - if (maxDuration_2 <= -0.6130513846874237) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398807287216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6085431575775146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.42576293647289276) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.1941896453499794) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.16942478716373444) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5920597612857819) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617918729782104) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.24272609502077103) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4498812556266785) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.5418986082077026) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7708433568477631) { - if (averageDuration_2 <= -0.3478282243013382) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 0.23312640190124512) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.23145928233861923) { - if (averageDuration_2 <= -0.16028878837823868) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2745980769395828) { - if (maxDuration_2 <= -0.033908216282725334) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5914424359798431) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.16737931221723557) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.3343760669231415) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4087417274713516) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.09322386980056763) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.0011627247731667012) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (maxDuration_2 <= -0.10821232944726944) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.707603245973587) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.10416875779628754) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.11399137228727341) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.39911821484565735) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.09541979804635048) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.1866975501179695) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.43961067497730255) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614039659500122) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.15497000515460968) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1717139557003975) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3012038618326187) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.031132339499890804) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612632393836975) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5798149406909943) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.19475939869880676) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26718054711818695) { - if (averageDuration_2 <= -0.48565714061260223) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4939206540584564) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (numDurations_2 <= -0.12976674735546112) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.037075139582157135) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3324902802705765) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5342159569263458) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.361087366938591) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.26585550606250763) { - if (averageDuration_2 <= -0.33556507527828217) { - if (averageDuration_2 <= -0.43192683160305023) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (averageDuration_2 <= -0.3647909164428711) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3494781106710434) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748583048582077) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.3439832329750061) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7468894422054291) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.46466776728630066) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4107353240251541) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (averageDuration_2 <= -0.1585393249988556) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485209107398987) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5340007245540619) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.0545014007948339) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4769394248723984) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3260144591331482) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461271047592163) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615974426269531) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5098969042301178) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6485679149627686) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7385323941707611) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.20011595636606216) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1891184002161026) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.06767288595438004) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6448647081851959) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485521733760834) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6138264834880829) { - if (averageDuration_2 <= -0.23387668281793594) { - if (maxDuration_2 <= -0.39490559697151184) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - if (maxDuration_2 <= -0.4254269152879715) { - if (averageDuration_2 <= -0.3160969465970993) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.70689257979393) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.313244104385376) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.0048859119415283) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5401894152164459) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3328492641448975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5573665201663971) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3073357343673706) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3692297041416168) { - if (averageDuration_2 <= -0.39892035722732544) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5975027680397034) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6492940485477448) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.386329784989357) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.15189256519079208) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7064080834388733) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48656901717185974) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15483064204454422) { - if (averageDuration_2 <= -0.31090596318244934) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.3310801535844803) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.30606357753276825) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.46891026198863983) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4919792115688324) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.35769978165626526) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.41259224712848663) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.35252854228019714) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (maxDuration_2 <= -0.4991917163133621) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461735188961029) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5864637792110443) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { - if (maxDuration_2 <= -0.23609291017055511) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.21620120853185654) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.4272029399871826) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7479060888290405) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7602596282958984) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (averageDuration_2 <= -0.3254978358745575) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5168293416500092) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.12670142203569412) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5703205764293671) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5287594795227051) { - if (averageDuration_2 <= -0.37135712802410126) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0805509015917778) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.57000932097435) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4221958518028259) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.020724645350128412) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.21614987403154373) { - if (maxDuration_2 <= -0.48240742087364197) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.43773965537548065) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5399881303310394) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485050559043884) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (averageDuration_2 <= -0.34997664391994476) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5332325994968414) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5385791659355164) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.40933309495449066) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.1954646185040474) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7365859746932983) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619598984718323) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4374384135007858) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.25147758424282074) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615915417671204) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.3406946361064911) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3722996264696121) { - if (maxDuration_2 <= -0.318879172205925) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486171722412109) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485743761062622) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7447555661201477) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486171722412109) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.27423177659511566) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.4036545902490616) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.22167803347110748) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.24704985320568085) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.43059241771698) { - if (maxDuration_2 <= -0.39243610203266144) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.4684813618659973) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.24007270485162735) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0529265608638525) { - if (averageDuration_2 <= -0.4789075255393982) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.06270938011584803) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748584657907486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.695807009935379) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461421549320221) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.6009113788604736) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6571535468101501) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.009557085111737251) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (numDurations_2 <= -0.9834946841001511) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07424503192305565) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.6288356482982635) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1725463718175888) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.49582792818546295) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - if (numDurations_2 <= 0.43938523530960083) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7155901193618774) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.28862933814525604) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - if (averageDuration_2 <= -0.46872568130493164) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07167908176779747) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.04285782016813755) { - if (averageDuration_2 <= -0.46103353798389435) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4623077511787415) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2055632472038269) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22886675596237183) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988822154700756) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4250350594520569) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4498503506183624) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.584939181804657) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2669576555490494) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.30125565826892853) { - if (averageDuration_2 <= -0.6300389766693115) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5051824152469635) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.6538885235786438) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2452918365597725) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.08364953845739365) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06604358926415443) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615065455436707) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18552514910697937) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.43779824674129486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.47833119332790375) { - if (averageDuration_2 <= -0.5713742077350616) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5152589678764343) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4163975715637207) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3819584399461746) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.45608825981616974) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5744371116161346) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.5074199438095093) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485424280166626) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.46545979380607605) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485651671886444) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17166516184806824) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.435471773147583) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.532338559627533) { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5232116281986237) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.32090237736701965) { - if (averageDuration_2 <= -0.24739494174718857) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (maxDuration_2 <= -0.363629087805748) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.41922347247600555) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.22670163959264755) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.8750421404838562) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.2110331952571869) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1837560385465622) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.06582276150584221) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (averageDuration_2 <= -0.37779204547405243) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4408485144376755) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07599927112460136) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.35519783198833466) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20365030318498611) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0803013602271676) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5533127784729004) { - if (averageDuration_2 <= -0.3970071077346802) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23250308632850647) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - if (maxDuration_2 <= -0.37859490513801575) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.3282715678215027) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.20586559176445007) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0790926031768322) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0731804370880127) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.3677852749824524) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1176927238702774) { - if (averageDuration_2 <= -0.2579067796468735) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.39545752108097076) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2537977695465088) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.9304614961147308) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6542955935001373) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09303806722164154) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (averageDuration_2 <= -0.4055502414703369) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (averageDuration_2 <= -0.07717474922537804) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (averageDuration_2 <= -0.33939434587955475) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5418084263801575) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.178146094083786) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.2084173560142517) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - if (maxDuration_2 <= -0.4661272317171097) { - if (averageDuration_2 <= -0.3737822026014328) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.3327739089727402) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (averageDuration_2 <= -0.347231850028038) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5545052289962769) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6963427662849426) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485911548137665) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614967703819275) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4622482061386108) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.4960829168558121) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.019909122958779335) { - if (averageDuration_2 <= -0.3836795538663864) { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.0268927812576294) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614030122756958) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8702580034732819) { - if (maxDuration_2 <= -0.37985122203826904) { - if (averageDuration_2 <= -0.3853563815355301) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.33158570528030396) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1191994547843933) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4371566772460938) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.554470419883728) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.7970774918794632) { - if (averageDuration_2 <= -0.34461481869220734) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 0.08547664806246758) { - if (averageDuration_2 <= -0.2943752259016037) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - if (maxDuration_2 <= -0.3287896066904068) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.09727991744875908) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.48045238852500916) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.15083543211221695) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.19596700370311737) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6162827610969543) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.013856448233127594) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.585039883852005) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.3231832683086395) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.448899269104004) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.12713701650500298) { - if (maxDuration_2 <= -0.27950336039066315) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (maxDuration_2 <= -0.2518235743045807) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17754186689853668) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.10035017877817154) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5684525072574615) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.19312189519405365) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485952377319336) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05984428524971008) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.429594099521637) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4500522017478943) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.07842618972063065) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1106979064643383) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.46954141557216644) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619374871253967) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (maxDuration_2 <= -0.31687071919441223) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (maxDuration_2 <= -0.2285911962389946) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.008545245043933392) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.38869279623031616) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.24204733967781067) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.4651928246021271) { - if (averageDuration_2 <= -0.3771643340587616) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2997138798236847) { - if (averageDuration_2 <= -0.3675195276737213) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486171722412109) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.470812126994133) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.18549950420856476) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5444612205028534) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.009863323532044888) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (maxDuration_2 <= -0.33208952844142914) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0718638002872467) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.30602969229221344) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5957303643226624) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.07018454186618328) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3882166147232056) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.39599609375) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142840951681) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.05622479319572449) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.10064147040247917) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5017101019620895) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3111286908388138) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485521733760834) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486079931259155) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.29417721927165985) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.18212772905826569) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.04889783263206482) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18738115578889847) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5427532494068146) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5591905117034912) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485294342041016) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.2019961252808571) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5322945713996887) { - if (averageDuration_2 <= -0.36329546570777893) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.39341555535793304) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (averageDuration_2 <= -0.1315813958644867) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.15519636124372482) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.19040828943252563) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.08886498957872391) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (averageDuration_2 <= -0.13396944105625153) { - if (averageDuration_2 <= -0.40161460638046265) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (maxDuration_2 <= -0.13448134809732437) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618749618530273) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.17735284566879272) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618397951126099) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1888403594493866) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.28842975199222565) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11544476449489594) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.32608775794506073) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5948984622955322) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9542279541492462) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.0585829615592957) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4411871433258057) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.13334167748689651) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6009238660335541) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5486850738525391) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.6086798906326294) { - if (averageDuration_2 <= -0.19284972548484802) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404551506042) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.45875778794288635) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4634343385696411) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4271758198738098) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.18252739310264587) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483670711517) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4623731970787048) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17323505878448486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.27381957322359085) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.19196251034736633) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.31158509850502014) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.1741941049695015) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.564587339758873) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8647972941398621) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.32303541898727417) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.04989788681268692) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7849974930286407) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.4230196475982666) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485733032226562) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617557525634766) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3128224015235901) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.04634569585323334) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3742292821407318) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (maxDuration_2 <= -0.13867558538913727) { - if (averageDuration_2 <= -0.09006946533918381) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11714250594377518) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (maxDuration_2 <= -0.12964393943548203) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.30231238901615143) { - if (averageDuration_2 <= -0.5025456547737122) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484799027442932) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.33816035091876984) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5038608610630035) { - if (maxDuration_2 <= -0.4149087071418762) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (maxDuration_2 <= -0.44625823199748993) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485806047916412) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.41941168904304504) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.13165994733572006) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.22072111070156097) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248238757252693) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.24461984634399414) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.2549711614847183) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (averageDuration_2 <= -0.41125287115573883) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514857307076) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964074045419693) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (averageDuration_2 <= -0.3392566740512848) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.21270109713077545) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2620590478181839) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.4995386600494385) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (maxDuration_2 <= -0.1411929950118065) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.03645376116037369) { - if (averageDuration_2 <= -0.3692460358142853) { - if (maxDuration_2 <= -0.4048158824443817) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0239300727844238) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.21624477952718735) { - if (averageDuration_2 <= -0.5941737592220306) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (averageDuration_2 <= -0.5134525299072266) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5709969699382782) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.21470312774181366) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.14238231629133224) { - if (averageDuration_2 <= -0.371366411447525) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6067546904087067) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.18146149814128876) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (maxDuration_2 <= -0.290973961353302) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5059475600719452) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.22102482616901398) { - if (maxDuration_2 <= -0.44921649992465973) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (maxDuration_2 <= -0.33664846420288086) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6912778913974762) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4093919396400452) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.17261873185634613) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.967400997877121) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.06424967106431723) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.653190016746521) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5018784701824188) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461836814880371) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5431978404521942) { - if (averageDuration_2 <= -0.393062025308609) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.03404129762202501) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - if (averageDuration_2 <= -0.0007950448198243976) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618417024612427) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.32562756538391113) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.9265406876802444) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485960125923157) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13230181485414505) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5323525667190552) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.09061892330646515) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.1820175126194954) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.059369206428528) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5605961978435516) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2812333106994629) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32915425300598145) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5607762932777405) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8632377088069916) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.4283110201358795) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6281251907348633) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.311371847987175) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.20424193143844604) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.2342447191476822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2969321012496948) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.12996051460504532) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (averageDuration_2 <= -0.117515929043293) { - if (maxDuration_2 <= -0.1691742092370987) { - if (averageDuration_2 <= -0.3344445526599884) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0494094491004944) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (maxDuration_2 <= -0.2986302971839905) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6229180097579956) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.3281133621931076) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3492284119129181) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.15628253668546677) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.46148020029068) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.14508580416440964) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (averageDuration_2 <= -0.08140381053090096) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.054250599816441536) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.2447572872042656) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.38797543942928314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.06779986619949341) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6806835532188416) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.2398415058851242) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.17757514119148254) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6313913464546204) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.7111433446407318) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.1767014041543007) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7304023802280426) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.18839267641305923) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15805791318416595) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.134348064661026) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4936756044626236) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5386260449886322) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8144661486148834) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.210120789706707) { - if (averageDuration_2 <= -0.411627396941185) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.23294053971767426) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4171983301639557) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485838532447815) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5011187791824341) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484790682792664) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.47022151947021484) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7442229390144348) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (averageDuration_2 <= -0.22152316570281982) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (averageDuration_2 <= -0.43750278651714325) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.33040323853492737) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2692529186606407) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2076359987258911) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.10894132405519485) { - if (averageDuration_2 <= -0.7026169300079346) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07571825012564659) { - if (averageDuration_2 <= -0.2833278179168701) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32755759358406067) { - if (maxDuration_2 <= -0.49297134578227997) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.45725663006305695) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5586313605308533) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4732368588447571) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.25455667078495026) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5468974411487579) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (numDurations_2 <= 0.7239612340927124) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.635094553232193) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.580347329378128) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15345080941915512) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5737443566322327) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6117481291294098) { - if (averageDuration_2 <= -0.14872479438781738) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.4682319760322571) { - if (averageDuration_2 <= -0.6329787373542786) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5265552699565887) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6364681124687195) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.24119549244642258) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5198698341846466) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.9766682758927345) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28985482454299927) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6870878636837006) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - if (averageDuration_2 <= -0.2330113723874092) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - if (maxDuration_2 <= -0.2729361802339554) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7481113374233246) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5617681741714478) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.31682224571704865) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485749125480652) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.36459027230739594) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3748958557844162) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2510738670825958) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485651671886444) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.3678411692380905) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.033834950998425484) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461551547050476) { - if (averageDuration_2 <= -0.4351094514131546) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.3786516338586807) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.26239001750946045) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484677135944366) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5395406186580658) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.25661545991897583) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5088426470756531) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.0933137871325016) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2898950576782227) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5421836376190186) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (maxDuration_2 <= -0.07538862153887749) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2396336793899536) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.09175312519073486) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (maxDuration_2 <= -0.06178549863398075) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7157882153987885) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.18791374564170837) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3710092157125473) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22841762751340866) { - if (averageDuration_2 <= -0.30653025209903717) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.35229504108428955) { - if (averageDuration_2 <= -0.4406532943248749) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7248112261295319) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522207856178284) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.3586006313562393) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5140326768159866) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6012490391731262) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.49731501936912537) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4385754466056824) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5568554997444153) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484831213951111) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3319229334592819) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (averageDuration_2 <= -0.5757383704185486) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.613898754119873) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.16823644191026688) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.528982400894165) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617508053779602) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.443659707903862) { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.290977358818054) { - if (maxDuration_2 <= -0.4903828948736191) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.24775946885347366) { - if (maxDuration_2 <= -0.3933224678039551) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5105916857719421) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7483011782169342) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5256025493144989) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21374674141407013) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5628361999988556) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3866190314292908) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.3980271518230438) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.3673776090145111) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5177305340766907) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21284977346658707) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22005673497915268) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.3866794854402542) { - if (maxDuration_2 <= -0.4711825102567673) { - if (averageDuration_2 <= -0.3895966708660126) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - if (averageDuration_2 <= -0.19026585668325424) { - if (maxDuration_2 <= -0.5140534043312073) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4380033314228058) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.25149397552013397) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.536476343870163) { - if (averageDuration_2 <= -0.20907174795866013) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5337484776973724) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18107213824987411) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5156789720058441) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.21396403014659882) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4621152877807617) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5445589125156403) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42021267116069794) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5840253233909607) { - if (maxDuration_2 <= -0.3280450105667114) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.3253198564052582) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.41310399770736694) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (maxDuration_2 <= -0.6604152023792267) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13672755658626556) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485781610012054) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.32247303426265717) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6542955935001373) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.3078061491250992) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.29910269379615784) { - if (maxDuration_2 <= -0.5431819260120392) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5771022439002991) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7708979845046997) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3012620359659195) { - if (averageDuration_2 <= -0.5138199627399445) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3406316041946411) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (averageDuration_2 <= -0.6235829293727875) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5304751694202423) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09578686952590942) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.47485746443271637) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.6056628525257111) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5389014780521393) { - if (averageDuration_2 <= -0.6948243081569672) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 6.415480613708496) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7376938760280609) { - if (maxDuration_2 <= -0.7041648030281067) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (averageDuration_2 <= -0.6029072403907776) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4010132849216461) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616355299949646) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21628227084875107) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2961706221103668) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5637966990470886) { - if (maxDuration_2 <= -0.49066653847694397) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.282077819108963) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9102553725242615) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619072079658508) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3457256257534027) { - if (numDurations_2 <= -0.6989187002182007) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.30467693507671356) { - if (averageDuration_2 <= -0.24636389315128326) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.42191745340824127) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (averageDuration_2 <= -0.3778180032968521) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.41422486305236816) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.3155362457036972) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.38002657890319824) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0805245153605938) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.15032322704792023) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (maxDuration_2 <= -0.49999192357063293) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.13431144878268242) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.24069173634052277) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.02172175794839859) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.31877896189689636) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.4082011580467224) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17324179410934448) { - if (averageDuration_2 <= -0.24214886128902435) { - if (averageDuration_2 <= -0.34338271617889404) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5845167636871338) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.005252549424767494) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486035823822021) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14058390259742737) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7355774939060211) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1959613859653473) { - if (averageDuration_2 <= -0.2887658625841141) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748522937297821) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.22297777980566025) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.24751372635364532) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617391228675842) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4298177510499954) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.3458903580904007) { - if (averageDuration_2 <= -0.3958975821733475) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.49911367893219) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5875799059867859) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0415869653224945) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.645479142665863) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5497413575649261) { - if (averageDuration_2 <= -0.36234311759471893) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5333283245563507) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (maxDuration_2 <= -0.3028547316789627) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5626251697540283) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.45605458319187164) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.3926563858985901) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.4628068208694458) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21553750336170197) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20022210478782654) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (averageDuration_2 <= -0.17413567006587982) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461606204509735) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485708594322205) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.031044652685523033) { - if (maxDuration_2 <= -0.35985802114009857) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5798149406909943) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4527949094772339) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8376469910144806) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613345861434937) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.487790107727051) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486025393009186) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.24945639818906784) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (maxDuration_2 <= -0.42563460767269135) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.3194351941347122) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6070628464221954) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.24337955564260483) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.32716359198093414) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.0042311549186707) { - if (maxDuration_2 <= -0.4453490376472473) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.41970641911029816) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.31374046206474304) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07804489508271217) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.10775989666581154) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.46555641293525696) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5803781449794769) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21266233921051025) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (maxDuration_2 <= -0.08496975153684616) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0394643247127533) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485440373420715) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.1734088510274887) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (maxDuration_2 <= -0.10472219437360764) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3118554800748825) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.3284398019313812) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 1.5776891708374023) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0036615133285522) { - if (maxDuration_2 <= -0.08786974102258682) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.28968849778175354) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.533418208360672) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0711100734770298) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1249871551990509) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5410707592964172) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (averageDuration_2 <= -0.4505794048309326) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6884195506572723) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15311185270547867) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.08617021515965462) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0693339966237545) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7419182360172272) { - if (averageDuration_2 <= -0.4796365946531296) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0618066787719727) { - if (averageDuration_2 <= -0.5603125691413879) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18738047778606415) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1557490974664688) { - if (numDurations_2 <= 6.13090455532074) { - if (averageDuration_2 <= -0.5992408394813538) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { - if (averageDuration_2 <= -0.6441903412342072) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.9162233769893646) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.6844169795513153) { - if (maxDuration_2 <= -0.5782420039176941) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.3349531292915344) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6848448216915131) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.650844156742096) { - if (averageDuration_2 <= -0.6270786225795746) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19176141172647476) { - if (averageDuration_2 <= -0.6318793892860413) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485468983650208) { - if (maxDuration_2 <= -0.675710141658783) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6921019554138184) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6598462462425232) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8547589480876923) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.5853487253189087) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5878109335899353) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0761001892387867) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5718155205249786) { - if (maxDuration_2 <= -0.4557533860206604) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485237419605255) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5207372307777405) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7475999295711517) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (numDurations_2 <= 8.976664543151855) { - if (averageDuration_2 <= -0.7083494663238525) { - if (maxDuration_2 <= -0.6145963668823242) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (maxDuration_2 <= -0.7031999230384827) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.2663294672966003) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2173927202820778) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28283192217350006) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7463460266590118) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484782636165619) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3082134872674942) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4168335199356079) { - if (numDurations_2 <= 4.4234490394592285) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - if (averageDuration_2 <= -0.6237941980361938) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485337555408478) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.9265406727790833) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6056435108184814) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7550370395183563) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6620512008666992) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.05159341171383858) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.32052081823349) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.47320613265037537) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (averageDuration_2 <= -0.6907609403133392) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5259695649147034) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.12618356943130493) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6325519979000092) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22981225699186325) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.4623687416315079) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.3416352868080139) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4460074305534363) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= -0.6989187151193619) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1051611565053463) { - if (averageDuration_2 <= -0.5825749933719635) { - if (averageDuration_2 <= -0.6988268196582794) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7482359409332275) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.458168163895607) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.6953058838844299) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 6.415480613708496) { - if (maxDuration_2 <= -0.6085506975650787) { - if (averageDuration_2 <= -0.6439020931720734) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.717968076467514) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748550534248352) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.6379198729991913) { - if (maxDuration_2 <= -0.4606516510248184) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.619862973690033) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484246492385864) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.15533334761857986) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (averageDuration_2 <= -0.5787821412086487) { - if (maxDuration_2 <= -0.7166713774204254) { - if (averageDuration_2 <= -0.6765855550765991) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (averageDuration_2 <= -0.7119443416595459) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20668157190084457) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.6402873992919922) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748564600944519) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.31875666975975037) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.06399912759661674) { - if (maxDuration_2 <= -0.5114751756191254) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1310025304555893) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.4957597106695175) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2559058740735054) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.45281267166137695) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= -0.6989187151193619) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.600795567035675) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2668423652648926) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (averageDuration_2 <= -0.6890560388565063) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - if (averageDuration_2 <= -0.6005030870437622) { - if (averageDuration_2 <= -0.6944815814495087) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6913794279098511) { - if (averageDuration_2 <= -0.644711822271347) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6318919956684113) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2605709284543991) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5674171447753906) { - if (maxDuration_2 <= -0.6506591737270355) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2872399240732193) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6305203437805176) { - if (maxDuration_2 <= -0.6798838973045349) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (maxDuration_2 <= -0.7350054085254669) { - if (maxDuration_2 <= -0.7414765357971191) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37743450701236725) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.23255515843629837) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7482427060604095) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4549897313117981) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.30007487535476685) { - if (maxDuration_2 <= -0.641447901725769) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3775891065597534) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485239803791046) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.45882824063301086) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5103582739830017) { - if (averageDuration_2 <= -0.6077247262001038) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6201552152633667) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.705582857131958) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6956386864185333) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.3677852749824524) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5928784608840942) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.36483073234558105) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.6284285485744476) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (maxDuration_2 <= -0.7082425057888031) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3344017267227173) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.620060920715332) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4195927232503891) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0394643247127533) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748570591211319) { - if (averageDuration_2 <= -0.6524563431739807) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.7328249216079712) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485913038253784) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3285861313343048) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4866477996110916) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6388697028160095) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.326301708817482) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7196970283985138) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.7128343284130096) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2731478065252304) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006180226802826) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (maxDuration_2 <= -0.6363495290279388) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (averageDuration_2 <= -0.5770213305950165) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (averageDuration_2 <= -0.6162370443344116) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486047148704529) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - if (averageDuration_2 <= -0.6232931613922119) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6631428301334381) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7465344667434692) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (maxDuration_2 <= -0.719897985458374) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6552769839763641) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.6391245424747467) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7164249420166016) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6667593717575073) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.45215916633605957) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.6639102697372437) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.21396403014659882) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.6393508911132812) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6562292575836182) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8171539902687073) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3736784756183624) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6379959583282471) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.6697512865066528) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6474349498748779) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.610166609287262) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7709015309810638) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486041486263275) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5877041816711426) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.35595713555812836) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3173746168613434) { - if (averageDuration_2 <= -0.5992724001407623) { - if (maxDuration_2 <= -0.6478936672210693) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (averageDuration_2 <= -0.7171596884727478) { - if (averageDuration_2 <= -0.7254830598831177) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4373031258583069) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3159213364124298) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1912640780210495) { - if (maxDuration_2 <= -0.7550998330116272) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.134287178516388) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42268049716949463) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.14663732051849365) { - if (averageDuration_2 <= -0.6037571430206299) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (numDurations_2 <= 6.13090455532074) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3671959787607193) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13406617939472198) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.6847387254238129) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.01740696281194687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17010634392499924) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7089330554008484) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.7174064218997955) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.009127657394856215) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { - if (averageDuration_2 <= -0.7136951982975006) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7479373216629028) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.7154228389263153) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484016120433807) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.04575827158987522) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1190391443669796) { - if (averageDuration_2 <= -0.6405648291110992) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5516676604747772) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2619217783212662) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5947045087814331) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.190188705921173) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6929136514663696) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.7240389585494995) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6351701617240906) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (averageDuration_2 <= -0.599729597568512) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.605320006608963) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22908497601747513) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.29822908341884613) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000302791595) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26695604622364044) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1129172332584858) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3451772928237915) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.6156743764877319) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22087455540895462) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6578333377838135) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6883558630943298) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5438152253627777) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.01601999532431364) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8261885643005371) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088490307331085) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= 6.13090455532074) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1772996261715889) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.25469575822353363) { - if (averageDuration_2 <= -0.6963765919208527) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (averageDuration_2 <= -0.6106477081775665) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (maxDuration_2 <= -0.6423773169517517) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.04984685266390443) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11133436113595963) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (averageDuration_2 <= -0.5817033648490906) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (maxDuration_2 <= -0.707409143447876) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - if (averageDuration_2 <= -0.5885096490383148) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6319730877876282) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09039109200239182) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - if (maxDuration_2 <= -0.6109693944454193) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486074268817902) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6253879964351654) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.603890597820282) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486084997653961) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07622340321540833) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4310636818408966) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6133097112178802) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485196888446808) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.5795755684375763) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.6802361309528351) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.40831059217453003) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.42058065533638) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27485162019729614) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.2258937805891037) { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.6886387169361115) { - if (maxDuration_2 <= -0.4476083368062973) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.12272714078426361) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.477775514125824) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3461138904094696) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.29962058365345) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066322088241577) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.5821956992149353) { - if (averageDuration_2 <= -0.6537623405456543) { - if (maxDuration_2 <= -0.37809085845947266) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15508370101451874) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3990137428045273) { - if (maxDuration_2 <= -0.5636664628982544) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.32241390645504) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.25149397552013397) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.29727524518966675) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485294342041016) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.24407511949539185) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5848534405231476) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.26164135336875916) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.024194462224841118) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.25132977217435837) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.40059639513492584) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.425312876701355) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.5955186784267426) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.33948375284671783) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.32677866518497467) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.04892372526228428) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2672947496175766) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2733055055141449) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4480099380016327) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5633839070796967) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.11780998855829239) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485050857067108) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.5814078450202942) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13734575361013412) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (maxDuration_2 <= -0.4968235343694687) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.654631108045578) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3919743448495865) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5644879043102264) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1644773706793785) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6384816765785217) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5765884220600128) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (averageDuration_2 <= -0.5810084939002991) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15274066478013992) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (averageDuration_2 <= -0.5727010667324066) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.3660252094268799) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4479955583810806) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (maxDuration_2 <= -0.4368012547492981) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { - if (averageDuration_2 <= -0.5803948044776917) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3147025853395462) { - if (numDurations_2 <= -0.9834946841001511) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.5359943211078644) { - if (averageDuration_2 <= -0.5965176820755005) { - if (numDurations_2 <= 6.13090455532074) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.24501170217990875) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.385641872882843) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5726670324802399) { - if (maxDuration_2 <= -0.5782724320888519) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.24444470554590225) { - if (averageDuration_2 <= -0.5863527655601501) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.5855134725570679) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748615950345993) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6076204478740692) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2913016676902771) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0394643247127533) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (averageDuration_2 <= -0.7059626579284668) { - if (averageDuration_2 <= -0.7074968814849854) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.016474337899126112) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (averageDuration_2 <= -0.5784774720668793) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.668639749288559) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.387081116437912) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.2942512184381485) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.6306909620761871) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.48175404965877533) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.404605895280838) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485353946685791) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3778701722621918) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4420737624168396) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.3631354570388794) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.6306501626968384) { - if (maxDuration_2 <= -0.06621511653065681) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.060650864616036415) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (maxDuration_2 <= -0.15389452129602432) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2067742869257927) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488866329193) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (maxDuration_2 <= -0.5888818204402924) { - if (averageDuration_2 <= -0.5965440571308136) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (numDurations_2 <= 6.13090455532074) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07630449905991554) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (averageDuration_2 <= -0.7083695828914642) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.23457122594118118) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.45010609924793243) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.022631909232586622) { - if (averageDuration_2 <= -0.710541307926178) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6513368189334869) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1442170813679695) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22352147102355957) { - if (maxDuration_2 <= -0.6324492394924164) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.07682698452845216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6031441986560822) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2892048507928848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3788013160228729) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5981089174747467) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41282257437705994) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.47287702560424805) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940378189087) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15348324179649353) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.05899206921458244) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1432473286986351) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485944032669067) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6512995362281799) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3526008576154709) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6609622836112976) { - if (averageDuration_2 <= -0.6172437965869904) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.6289971768856049) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6209229230880737) { - if (averageDuration_2 <= -0.627981036901474) { - if (maxDuration_2 <= -0.7296184301376343) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7483750879764557) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2498645856976509) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6822977364063263) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2446881532669067) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (averageDuration_2 <= -0.665375143289566) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.9391517639160156) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.8154819160699844) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11712650582194328) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.17370933294296265) { - if (maxDuration_2 <= -0.634520947933197) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.609994649887085) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118843227625) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.60809725522995) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0043932057451456785) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6529995799064636) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (maxDuration_2 <= -0.6758011281490326) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.31715817749500275) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5995317697525024) { - if (averageDuration_2 <= -0.5742016136646271) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.5857761800289154) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6393659710884094) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22990572452545166) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (maxDuration_2 <= -0.6601163148880005) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.26355937123298645) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2829601541161537) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.6311676800251007) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.28807908296585083) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5566710829734802) { - if (numDurations_2 <= -0.12976674735546112) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486057877540588) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (maxDuration_2 <= -0.4519239813089371) { - if (averageDuration_2 <= -0.6322380900382996) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484888136386871) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3260877653956413) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (averageDuration_2 <= -0.6714364886283875) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18646074086427689) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6571762561798096) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4070816785097122) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.4532155990600586) { - if (averageDuration_2 <= -0.5735413432121277) { - if (numDurations_2 <= 6.13090455532074) { - if (averageDuration_2 <= -0.6183644831180573) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (maxDuration_2 <= -0.5734679400920868) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6390793323516846) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.24209287017583847) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2766965329647064) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748584657907486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5499264299869537) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.6301092505455017) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2803422212600708) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.6112167537212372) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4160782992839813) { - if (maxDuration_2 <= -0.13017592951655388) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6461068987846375) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.02456360124051571) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484260201454163) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6396100521087646) { - if (averageDuration_2 <= -0.6314571499824524) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (maxDuration_2 <= -0.6232276558876038) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5380506217479706) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3189091086387634) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17654238641262054) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7473077476024628) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - if (maxDuration_2 <= -0.4764505624771118) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6330539584159851) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.725941002368927) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.20673715323209763) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (maxDuration_2 <= -0.6267683506011963) { - if (averageDuration_2 <= -0.6196272969245911) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.27056601643562317) { - if (averageDuration_2 <= -0.6513076424598694) { - if (maxDuration_2 <= -0.6814112067222595) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.66437628865242) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.755755752325058) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.40310265123844147) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.5751760303974152) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6979712247848511) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3417718708515167) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.30776816606521606) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (averageDuration_2 <= -0.6111786365509033) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.58139568567276) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6276070773601532) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (maxDuration_2 <= -0.2807570695877075) { - if (maxDuration_2 <= -0.6341030895709991) { - if (averageDuration_2 <= -0.6270729303359985) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4963124692440033) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.57615065574646) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5754052400588989) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4602256864309311) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.632216215133667) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.5185667276382446) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5409769117832184) { - if (maxDuration_2 <= -0.6730633676052094) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.351614311337471) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8383578062057495) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2549879029393196) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.27733276784420013) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5847499668598175) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3549942225217819) { - if (numDurations_2 <= -0.9834946841001511) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5944424867630005) { - if (averageDuration_2 <= -0.7077423334121704) { - if (numDurations_2 <= -0.12976674735546112) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7239324450492859) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5793302059173584) { - if (averageDuration_2 <= -0.5952778160572052) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.10518838092684746) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.7500903606414795) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (averageDuration_2 <= -0.6413906812667847) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6661391258239746) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.22047889977693558) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.10000856593251228) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.479195833206177) { - if (averageDuration_2 <= -0.7038798332214355) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.5627588033676147) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6153299510478973) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.913651704788208) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.687044084072113) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5263607501983643) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (numDurations_2 <= -1.837222695350647) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7124274969100952) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (numDurations_2 <= 6.415480613708496) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.2164584398269653) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748409241437912) { - if (averageDuration_2 <= -0.7140871286392212) { - if (maxDuration_2 <= -0.7719548940658569) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484433352947235) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (maxDuration_2 <= -0.563701868057251) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.6651031672954559) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486269176006317) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.056468117982149124) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7477090358734131) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.11920559778809547) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { - if (maxDuration_2 <= -0.5697320997714996) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3257780075073242) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3945978134870529) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.850115954875946) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.21835432201623917) { - if (maxDuration_2 <= -0.7565460205078125) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5843615531921387) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.2638133466243744) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.518776923418045) { - if (maxDuration_2 <= -0.5615313053131104) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.5399122834205627) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.04819197207689285) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.05979132279753685) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0577878151088953) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.39341557025909424) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182126104831696) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486106753349304) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= -0.12976674735546112) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (averageDuration_2 <= -0.6158697605133057) { - if (numDurations_2 <= 6.13090455532074) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.346752107143402) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.35619115829467773) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.6555081903934479) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.48211367428302765) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06330370716750622) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.33432537317276) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.8825266361236572) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8302063345909119) { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3677114397287369) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.5886342525482178) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.2615691423416138) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.30358798801898956) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.29676733911037445) { - if (maxDuration_2 <= -0.47296299040317535) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.23138893395662308) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.03231381718069315) { - if (maxDuration_2 <= -0.6112202107906342) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.5869139432907104) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.6821785569190979) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.309469535946846) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.31486302614212036) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.12313800305128098) { - if (maxDuration_2 <= -0.4479603171348572) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.20255523920059204) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7459561228752136) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (averageDuration_2 <= -0.5777261853218079) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.39037685096263885) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (maxDuration_2 <= -0.5787991583347321) { - if (averageDuration_2 <= -0.6474884748458862) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.33143238723278046) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5596874952316284) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.03922520764172077) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11987308040261269) { - if (averageDuration_2 <= -0.7153560817241669) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.25571219623088837) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.27030202746391296) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - if (averageDuration_2 <= -0.6822157800197601) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { - if (averageDuration_2 <= -0.5686883330345154) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8632377088069916) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.03243057616055012) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8382551670074463) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.014264244586229324) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.7029103636741638) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6102865934371948) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6678425371646881) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.20619194209575653) { - if (maxDuration_2 <= -0.5121411979198456) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.6585640013217926) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.12766677513718605) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.6652712225914001) { - if (maxDuration_2 <= -0.6405665278434753) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (averageDuration_2 <= -0.7103055715560913) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.86341992020607) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5701518654823303) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8883264660835266) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.7789206802845001) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.0258095264434814) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7776145040988922) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (maxDuration_2 <= -0.5265017151832581) { - if (averageDuration_2 <= -0.5748074650764465) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.49859820306301117) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 1.008537232875824) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.6531873643398285) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6031866371631622) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.47222697734832764) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5606751143932343) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.4652512073516846) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.4333643764257431) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1668703630566597) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.6015757620334625) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (numDurations_2 <= -0.1297668218612671) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (averageDuration_2 <= -0.5090069472789764) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.37704744935035706) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3945338577032089) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.39162302017211914) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6396725177764893) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485932111740112) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.4799177944660187) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - if (averageDuration_2 <= -0.5157861709594727) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4963555485010147) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (maxDuration_2 <= -0.523115336894989) { - if (numDurations_2 <= -0.9834946841001511) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21989356726408005) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07211801409721375) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6992646157741547) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.514002114534378) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3535720854997635) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5339557230472565) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.021550768986344337) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5400970131158829) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3575439304113388) { - if (averageDuration_2 <= -0.5053788423538208) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4008818417787552) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7465963959693909) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.2951493263244629) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.55132195353508) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.536685585975647) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7300782799720764) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.0904808733612299) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.5423820614814758) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6613061428070068) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485489249229431) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.6020848155021667) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4501224458217621) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6546749770641327) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (maxDuration_2 <= -0.5426652431488037) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485353648662567) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748611718416214) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41778795421123505) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22760175913572311) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6238977313041687) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2172144055366516) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8477074503898621) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27458997070789337) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2008805200457573) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5800697803497314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5400970131158829) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09641676023602486) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5156345367431641) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485502362251282) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.5403487384319305) { - if (maxDuration_2 <= -0.5728347599506378) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5546594858169556) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995391011238) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.5246325135231018) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.041432201862335205) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6140949130058289) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3001602292060852) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5303878486156464) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.320826455950737) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (averageDuration_2 <= -0.5155457556247711) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6946036219596863) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (averageDuration_2 <= -0.5432513654232025) { - if (maxDuration_2 <= -0.5330384373664856) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.524500846862793) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.033411760814487934) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486041486263275) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5188440382480621) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4751361012458801) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (maxDuration_2 <= -0.504801481962204) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5019201040267944) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936677023768425) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5351015627384186) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4165748506784439) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (averageDuration_2 <= -0.5459118485450745) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.16147871315479279) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5140326619148254) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.33931100368499756) { - if (averageDuration_2 <= -0.5472012460231781) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15178409218788147) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485724985599518) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6505235135555267) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.27381957322359085) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485629916191101) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (maxDuration_2 <= -0.49931828677654266) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5203522741794586) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42465922236442566) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5095495581626892) { - if (averageDuration_2 <= -0.5018729418516159) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41188301146030426) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5394716262817383) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18903633207082748) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.37186598777770996) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5261901021003723) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (averageDuration_2 <= -0.5465414524078369) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.06601044908165932) { - if (maxDuration_2 <= -0.49377672374248505) { - if (maxDuration_2 <= -0.49413132667541504) { - if (averageDuration_2 <= -0.4932745695114136) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7471111714839935) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.5656722784042358) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.04947089031338692) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3331745117902756) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.35815654695034027) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08901536464691162) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4484865516424179) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.5592569708824158) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5141507089138031) { - if (maxDuration_2 <= -0.6598884463310242) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.8837427794933319) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4043412506580353) { - if (maxDuration_2 <= -0.5947931110858917) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (averageDuration_2 <= -0.5168949663639069) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5319100320339203) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { - if (maxDuration_2 <= -0.6174859404563904) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3044580817222595) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (maxDuration_2 <= -0.5177308619022369) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.33912962675094604) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2491239532828331) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.556867927312851) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5040348470211029) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3708195388317108) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.589312344789505) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9738000631332397) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5010989606380463) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.5331955254077911) { - if (maxDuration_2 <= -0.5040240287780762) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485310733318329) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2958206683397293) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4217275530099869) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6119897067546844) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.37255190312862396) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48718151450157166) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5557412505149841) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5481290817260742) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6785764694213867) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3984972685575485) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5603882968425751) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (maxDuration_2 <= -0.570489376783371) { - if (averageDuration_2 <= -0.5336717665195465) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - if (averageDuration_2 <= -0.5392078459262848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.5380181074142456) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4977605491876602) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.35893236100673676) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.38399451971054077) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.08076433464884758) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { - if (maxDuration_2 <= -0.4746117442846298) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2721313089132309) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7019435465335846) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17904957383871078) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485529780387878) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.10792580991983414) { - if (numDurations_2 <= 0.4393852949142456) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.33317744731903076) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (maxDuration_2 <= -0.5609033107757568) { - if (maxDuration_2 <= -0.6151078343391418) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.856589436531067) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.02740886528044939) { - if (averageDuration_2 <= -0.52540123462677) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5648077130317688) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0336533784866333) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5795921385288239) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.5170522034168243) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - if (maxDuration_2 <= -0.6232731640338898) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9145718514919281) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5441612005233765) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.40236958861351013) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= -0.12976674735546112) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.9915950894355774) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.985200524330139) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.1097114086151123) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.021669305860996246) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5329894721508026) { - if (averageDuration_2 <= -0.5321161448955536) { - if (maxDuration_2 <= -0.4252496063709259) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (maxDuration_2 <= -0.3020593523979187) { - if (averageDuration_2 <= -0.5010087490081787) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08745496487244964) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486269176006317) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (maxDuration_2 <= -0.38494184613227844) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13690149411559105) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (averageDuration_2 <= -0.5077832937240601) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4070816785097122) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5176326632499695) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3339397609233856) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3228241354227066) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18755441904067993) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.206382632255554) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5189287960529327) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.2392147183418274) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.5256039500236511) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4098938852548599) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5418279767036438) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.2110331878066063) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6461068987846375) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.05159341171383858) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.5804793536663055) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - if (maxDuration_2 <= -0.4631108492612839) { - if (averageDuration_2 <= -0.5925170183181763) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.530704975128174) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4391782879829407) { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.15851354598999) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.8321900367736816) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6590698957443237) { - if (maxDuration_2 <= -0.5414976477622986) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.27363070845603943) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4195858240127563) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - if (maxDuration_2 <= -0.7442802488803864) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3148750364780426) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.9705548286437988) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.474243879318237) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.16583268344402313) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4981125742197037) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.7543967962265015) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6060645282268524) { - if (averageDuration_2 <= -0.7158129215240479) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6415532827377319) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.6945228576660156) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.5400515496730804) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.1627421379089355) { - if (averageDuration_2 <= -0.6287789642810822) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.204942524433136) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23781486600637436) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5141507685184479) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (averageDuration_2 <= -0.6292324662208557) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23817314207553864) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.5675357580184937) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485694885253906) { - if (maxDuration_2 <= -0.6582167744636536) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7483588755130768) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.2287803292274475) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1570499762892723) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6845675408840179) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.700544685125351) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48397035896778107) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621881961823) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.8825266063213348) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096855916082859) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485619187355042) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.43416035175323486) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6056584119796753) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.719211608171463) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6320083737373352) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485595047473907) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15086404234170914) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8064739406108856) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8481956273317337) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616482257843018) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.6473364531993866) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4441741108894348) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.832190155982971) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6314084231853485) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3253257274627686) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485034465789795) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.8376701474189758) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5912991166114807) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.4230196475982666) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (maxDuration_2 <= -0.6019784510135651) { - if (maxDuration_2 <= -0.6525335311889648) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.289841890335083) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4221771955490112) { - if (averageDuration_2 <= -0.7086963951587677) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0351535379886627) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.3309372216463089) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.173550605773926) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.687044084072113) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4740087240934372) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.5919741690158844) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22585184127092361) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4515303075313568) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6578724682331085) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5345251560211182) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5193747878074646) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486106753349304) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.6797472536563873) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1641283594071865) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (maxDuration_2 <= -0.6402853429317474) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.5949248671531677) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (averageDuration_2 <= -0.5593745410442352) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.014264244586229324) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486139237880707) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5445377230644226) { - if (maxDuration_2 <= -0.6143708825111389) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (maxDuration_2 <= -0.6022113859653473) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (maxDuration_2 <= -0.6599821150302887) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.369388163089752) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6157208383083344) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.5144805908203125) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461919903755188) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.5047587752342224) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2731478065252304) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.46994833648204803) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.430754840373993) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3159213364124298) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6636316776275635) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.740447610616684) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.7768075168132782) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4608597159385681) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6412908136844635) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9074200093746185) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617987275123596) { - if (averageDuration_2 <= -0.5395024418830872) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6423529088497162) { - if (maxDuration_2 <= -0.623035192489624) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616658091545105) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6089862883090973) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5084951221942902) { - if (maxDuration_2 <= -0.6381757259368896) { - if (maxDuration_2 <= -0.6401056051254272) { - if (averageDuration_2 <= -0.5730026364326477) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4493311643600464) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.6284222602844238) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.30496953427791595) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4594019055366516) { - if (maxDuration_2 <= -0.5022282600402832) { - if (cpuCoreIdleTimesPercentage_2_2 <= -3.014857053756714) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5064204633235931) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486071586608887) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5037727653980255) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (maxDuration_2 <= -0.4612898677587509) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.11635999381542206) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6657199859619141) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.23255515843629837) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.5708335340023041) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5967322885990143) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.5062452554702759) { - if (maxDuration_2 <= -0.5075013935565948) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5548197031021118) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.48797938227653503) { - if (maxDuration_2 <= -0.4931486248970032) { - if (maxDuration_2 <= -0.49360957741737366) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4092605710029602) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5056869387626648) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5461997985839844) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.5259314477443695) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485781610012054) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5845027267932892) { - if (maxDuration_2 <= -0.5898594260215759) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.5247134268283844) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461901307106018) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485643625259399) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4401201605796814) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (averageDuration_2 <= -0.3643103986978531) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4706708490848541) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - if (averageDuration_2 <= -0.47107353806495667) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (maxDuration_2 <= -0.483347088098526) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.14702074229717255) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9895455539226532) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1014692522585392) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.614899069070816) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= -0.12976670265197754) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.14334552735090256) { - if (numDurations_2 <= 0.15480925142765045) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2678428888320923) { - if (maxDuration_2 <= -0.4268401563167572) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3800019323825836) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4700821340084076) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.4362072944641113) { - if (maxDuration_2 <= -0.22508838772773743) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6542955935001373) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.3296988308429718) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.938111960887909) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2657117396593094) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9263713657855988) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.459158182144165) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5120650827884674) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (averageDuration_2 <= -0.22536743432283401) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.20997031778097153) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (maxDuration_2 <= -0.20090125501155853) { - if (maxDuration_2 <= -0.4472789466381073) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuCoreIdleTimesPercentage_4_2 <= -5.2091405391693115) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.25260934233665466) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7447181642055511) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485988736152649) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.3967061936855316) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.09356221556663513) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.23222923278808594) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.17090608179569244) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.2673764079809189) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2166208252310753) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.11075641959905624) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5572963654994965) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.30099768936634064) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.29941584169864655) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485513687133789) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5235314071178436) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.23330730199813843) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0755597352981567) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.299454927444458) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1704033762216568) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.31715817749500275) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.21382441371679306) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (averageDuration_2 <= -0.0449118260294199) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.10823847725987434) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.28165359795093536) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.12319125235080719) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.23457122594118118) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1259622573852539) { - if (averageDuration_2 <= -0.17545931786298752) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.1256220079958439) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.029448035173118114) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.23222923278808594) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.21904607117176056) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.06286668963730335) { - if (maxDuration_2 <= -0.29095615446567535) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.20240458101034164) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.19196250289678574) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.02252345345914364) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.11780998483300209) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (maxDuration_2 <= -0.18354210257530212) { - if (averageDuration_2 <= -0.18870840221643448) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.32316190004348755) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.3202188313007355) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (maxDuration_2 <= -0.18496549874544144) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6542955935001373) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.19264373928308487) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748577356338501) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (maxDuration_2 <= -0.1073739156126976) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23567409813404083) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.16509276628494263) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (maxDuration_2 <= -0.08689983561635017) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.054554807022213936) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7478991150856018) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41117388010025024) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2760425806045532) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486171722412109) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19360028952360153) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.07256471738219261) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2711581438779831) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.45281267166137695) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3197200149297714) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.4811157286167145) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (averageDuration_2 <= -0.24051138758659363) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.419434368610382) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2010168433189392) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5417449176311493) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5404199957847595) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.2831329107284546) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.7624516487121582) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.2829435467720032) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.052657850086688995) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5307832658290863) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4570999145507812) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.645479142665863) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17854981124401093) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.376688003540039) { - if (averageDuration_2 <= -0.2118023931980133) { - if (averageDuration_2 <= -0.2137259840965271) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.11583025008440018) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.790669322013855) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.2761373966932297) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665165930986404) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.19004305452108383) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8387757241725922) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5792726874351501) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - if (averageDuration_2 <= -0.15520743280649185) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.527993343770504) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3311299979686737) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.29653505980968475) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.452691376209259) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.33287017047405243) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5400526225566864) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6254423558712006) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.4599164128303528) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5909016728401184) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.19416650384664536) { - if (maxDuration_2 <= -0.3163464069366455) { - if (averageDuration_2 <= -0.4182475209236145) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (averageDuration_2 <= -0.19587955623865128) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.47822894155979156) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1627480387687683) { - if (averageDuration_2 <= -0.23158440738916397) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.24310090392827988) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.33763113617897034) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.23783621191978455) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.217767596244812) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21405158936977386) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485164403915405) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486236691474915) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.36404065787792206) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.605915755033493) { - if (averageDuration_2 <= -0.21702267229557037) { - if (averageDuration_2 <= -0.39489197731018066) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.16068629175424576) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (averageDuration_2 <= -0.2548810988664627) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42635399103164673) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.09712367877364159) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3081279993057251) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.38210777938365936) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.14397023618221283) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485395669937134) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2587413787841797) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18581652641296387) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (maxDuration_2 <= -0.15951956808567047) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.4520125687122345) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486122846603394) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486204206943512) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.38568535447120667) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.29812364280223846) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.36859849095344543) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.45106177031993866) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4294846057891846) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.16245748847723007) { - if (maxDuration_2 <= -0.4652763605117798) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.4268300384283066) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091154009103775) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8936700522899628) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.16712819039821625) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.44695231318473816) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592867255211) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4062532037496567) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.4421443939208984) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - if (maxDuration_2 <= -0.3288401961326599) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4742417633533478) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.42441636323928833) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5800697803497314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0936996228992939) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614782333374023) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.320826455950737) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.456036314368248) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (averageDuration_2 <= -0.3758874088525772) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22147665172815323) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066322088241577) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.390625) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7240137457847595) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.175323273986578) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.40219008922576904) { - if (averageDuration_2 <= 0.0005997614935040474) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6279810667037964) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616716504096985) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { - if (numDurations_2 <= -1.837222695350647) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486147284507751) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486171722412109) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0478596817702055) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.07104289624840021) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748522937297821) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.06562501564621925) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.26456184685230255) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.26996414363384247) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8223898708820343) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.2901812344789505) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.5609686970710754) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.0812260508537292) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2918991446495056) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.006857895525172353) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606539070606) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.863446444272995) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5420771241188049) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.9565199911594391) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.21609492599964142) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614869952201843) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.3974560350179672) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5633972883224487) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4125909209251404) { - if (maxDuration_2 <= -0.32084693014621735) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { - if (averageDuration_2 <= -0.45444852113723755) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.10971175134181976) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.17337136715650558) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.47296473383903503) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3481670022010803) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13226541131734848) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.286694660782814) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.34946462512016296) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4170728772878647) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.4416525363922119) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485511004924774) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.019017704762518406) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.45277389883995056) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0362901985645294) { - if (maxDuration_2 <= -0.3497324436903) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5723944306373596) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.24440757185220718) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (averageDuration_2 <= -0.2888507544994354) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.032543187378905714) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485521733760834) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6669449806213379) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7114445269107819) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.06499477289617062) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8369991779327393) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2987431287765503) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (maxDuration_2 <= -0.5567596852779388) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.4457963556051254) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461283802986145) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.648976445198059) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.16854366660118103) { - if (maxDuration_2 <= -0.44621536135673523) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41196922957897186) { - if (maxDuration_2 <= -0.45157942175865173) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485196888446808) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22892621904611588) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8058932423591614) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.34377241134643555) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.32002659142017365) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15110697597265244) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4085633307695389) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485462427139282) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.39113272726535797) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615954756736755) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2243993803858757) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5635370314121246) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (maxDuration_2 <= -0.24272357672452927) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485405802726746) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461799681186676) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2605958729982376) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3060985952615738) { - if (maxDuration_2 <= -0.4404990077018738) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485395967960358) { - if (averageDuration_2 <= -0.31655801832675934) { - if (averageDuration_2 <= -0.4201143980026245) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485221326351166) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.27381957322359085) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.05089460499584675) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485952079296112) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486082315444946) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.07992473244667053) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27866485714912415) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.24115795642137527) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2925875037908554) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2904955744743347) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.4649350345134735) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.34949256479740143) { - if (averageDuration_2 <= -0.4578302204608917) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2420012503862381) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (averageDuration_2 <= -0.41511140763759613) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.36757953464984894) { - if (averageDuration_2 <= -0.44762371480464935) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.3546786457300186) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.4016246497631073) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3726281225681305) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.33423367142677307) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4239456206560135) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.35669392347335815) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.3132963925600052) { - if (maxDuration_2 <= -0.46219155192375183) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3819584399461746) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.33621934056282043) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.32631050050258636) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6730119585990906) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5798149406909943) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.4382731020450592) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4082258641719818) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.47392043471336365) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.33492837846279144) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485816776752472) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (maxDuration_2 <= -0.1570020690560341) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3744259476661682) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.46464112401008606) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2640967518091202) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1424911804497242) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7942454218864441) { - if (averageDuration_2 <= -0.21374227106571198) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.16492976248264313) { - if (averageDuration_2 <= -0.24888796359300613) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (averageDuration_2 <= -0.27414843440055847) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.01227972423657775) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8599216341972351) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27628175914287567) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.19508984684944153) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7014470100402832) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (maxDuration_2 <= -0.15677406638860703) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6438708007335663) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07319054007530212) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.3009806275367737) { - if (averageDuration_2 <= -0.28228411078453064) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6141973733901978) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6163232624530792) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18555010110139847) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.46791939437389374) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3559087887406349) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1873953491449356) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7867609560489655) { - if (averageDuration_2 <= -0.3722701668739319) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1783582866191864) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.4043188989162445) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.2481725662946701) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.4354717582464218) { - if (maxDuration_2 <= -0.3503655940294266) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.9565199613571167) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.2897071987390518) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (averageDuration_2 <= -0.25477904081344604) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3122410178184509) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.35789524018764496) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - if (maxDuration_2 <= -0.2122957780957222) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.2276564985513687) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20796751230955124) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4214019775390625) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0722964107990265) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485716640949249) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.3955571800470352) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5449985563755035) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6771047115325928) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.43062810599803925) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - if (maxDuration_2 <= -0.5373972058296204) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0108683109283447) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.36921538412570953) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.17726513743400574) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9677406549453735) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.1272986829280853) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9160395562648773) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.46368658542633057) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.4499184191226959) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5275512933731079) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.446727216243744) { - if (maxDuration_2 <= -0.4543781578540802) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618290066719055) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.121818721294403) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4254775643348694) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.925930917263031) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.45941805839538574) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.16412602365016937) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3735408186912537) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5682035982608795) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.4275415986776352) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.455130159854889) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6892416775226593) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616824388504028) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6838820278644562) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1380702555179596) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3385528177022934) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3520589768886566) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (averageDuration_2 <= -0.3757459223270416) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.3763286918401718) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6957041025161743) { - if (averageDuration_2 <= -0.3888409733772278) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.2830542027950287) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.33243660628795624) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4866507649421692) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.30060437321662903) { - if (averageDuration_2 <= -0.45740102231502533) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613903164863586) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5532271564006805) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20996110141277313) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.0774097442626953) { - if (maxDuration_2 <= -0.2342694029211998) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.39264850318431854) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48412199318408966) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.06767288967967033) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.17275911569595337) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.14831599220633507) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.1897422820329666) { - if (maxDuration_2 <= -0.4273213893175125) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484985888004303) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.701122909784317) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615759253501892) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13907665759325027) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8327971994876862) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615427255630493) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.5560935735702515) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19504929333925247) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4740087240934372) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2886967360973358) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5478068292140961) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616726636886597) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.4161391705274582) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.280378594994545) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2704838663339615) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7481509149074554) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13706288486719131) { - if (maxDuration_2 <= -0.3742387145757675) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6121544539928436) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.47511574625968933) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13414227962493896) { - if (averageDuration_2 <= -0.4588353633880615) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4605910181999207) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.25763140618801117) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.46432772278785706) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - if (maxDuration_2 <= -0.3286426067352295) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.45194506645202637) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.4760628193616867) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.016184553503990173) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37610098719596863) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7022022008895874) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5717683434486389) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615514874458313) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485684156417847) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.4610670804977417) { - if (averageDuration_2 <= -0.4672704190015793) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.13219693303108215) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.41715510189533234) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486074268817902) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4740087240934372) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5403721332550049) { - if (averageDuration_2 <= -0.0015529347583651543) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.2490766644477844) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2000451162457466) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4818741977214813) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2417157217860222) { - if (averageDuration_2 <= -0.3829553723335266) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2543259412050247) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5602551400661469) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486269176006317) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.35119329392910004) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818998217583) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (averageDuration_2 <= -0.42565564811229706) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.16291839629411697) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.40711306035518646) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1031596027314663) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19247859716415405) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.24851423501968384) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.11044968664646149) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5046090483665466) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345905259251595) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.32680052518844604) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (averageDuration_2 <= -0.3734745681285858) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.20815537124872208) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.04137381166219711) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7186876237392426) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9710132777690887) { - if (averageDuration_2 <= -0.3728286921977997) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0803013602271676) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5602262616157532) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5035108029842377) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.35733550041913986) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (maxDuration_2 <= -0.47628600895404816) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6598224937915802) { - if (averageDuration_2 <= -0.433050736784935) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3246244639158249) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.4072634279727936) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5026872158050537) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.24944493174552917) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.12023483589291573) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.33005325496196747) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.05928822420537472) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - if (averageDuration_2 <= -0.4457721710205078) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.6012653335928917) { - if (maxDuration_2 <= -0.10277709364891052) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9738087058067322) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.40085650980472565) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (averageDuration_2 <= -0.2254275307059288) { - if (maxDuration_2 <= -0.19366789609193802) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5949988663196564) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3833676874637604) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.8463466763496399) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.6086798906326294) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (averageDuration_2 <= -0.2150048017501831) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (averageDuration_2 <= -0.36736442148685455) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (averageDuration_2 <= -0.23991858214139938) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.22675355523824692) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484709620475769) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9049322307109833) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.25466300547122955) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5851186215877533) { - if (maxDuration_2 <= -0.30136051774024963) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7334688901901245) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.910904288291931) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.3926389813423157) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.005700349574908614) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617830514907837) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.018405020236969) { - if (numDurations_2 <= -1.837222695350647) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5121813416481018) { - if (maxDuration_2 <= -0.7903296053409576) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.023051044903695583) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.7823136746883392) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.30492761731147766) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.011927980929613113) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.003652036713901907) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4427055716514587) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7424591183662415) { - if (averageDuration_2 <= 0.05751620605587959) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5335726141929626) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.12016559392213821) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3715622425079346) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (maxDuration_2 <= -0.23854973167181015) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.42595982551574707) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7920783758163452) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12868332117795944) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.10699904710054398) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (maxDuration_2 <= -0.1915656514465809) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.4441435933113098) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1833718866109848) { - if (averageDuration_2 <= -0.5193924009799957) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8832673728466034) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.045107850804924965) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1979415714740753) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2001994326710701) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5818384885787964) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7200384140014648) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.4643927812576294) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= -1.837222695350647) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.42821288108825684) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4301474839448929) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.6887571215629578) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.015191368293017149) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5700184106826782) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.4803755283355713) { - if (maxDuration_2 <= -0.6873755753040314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6279993653297424) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.8837427794933319) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.5964350700378418) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.274163581430912) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5308651030063629) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.28999821841716766) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.020174313336610794) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21295372396707535) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7329195737838745) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.27601249516010284) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7397380769252777) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.524916410446167) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4010290205478668) { - if (maxDuration_2 <= -0.5428045392036438) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3895687609910965) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3035068064928055) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23857007920742035) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6204427778720856) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.43432486057281494) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.4687822759151459) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.5816560387611389) { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.39341557025909424) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.33300548791885376) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.4426897317171097) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.36191636323928833) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (maxDuration_2 <= -0.464225172996521) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.27163177728652954) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.5787796974182129) { - if (averageDuration_2 <= -0.6922681033611298) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3939834535121918) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6941463351249695) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.562934935092926) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (averageDuration_2 <= -0.6572836637496948) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6339364051818848) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6799893081188202) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.636779397726059) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.331957072019577) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42107343673706055) { - if (maxDuration_2 <= -0.4922596514225006) { - if (averageDuration_2 <= -0.6064842939376831) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2955031096935272) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3545657843351364) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6670986115932465) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.12016559392213821) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.45866842567920685) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6327858865261078) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5110780000686646) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0788019672036171) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - if (maxDuration_2 <= -0.36035455763339996) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6907223761081696) { - if (averageDuration_2 <= -0.47336338460445404) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.31011928617954254) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5201195478439331) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3351140320301056) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.471996933221817) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3458111137151718) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.38032156229019165) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.3007252961397171) { - if (averageDuration_2 <= -0.44142450392246246) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3655364513397217) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4022200405597687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4199192374944687) { - if (averageDuration_2 <= -0.39238764345645905) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 0.7239612638950348) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5951146483421326) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.37378986179828644) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.33352920413017273) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.24393915385007858) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.4866066426038742) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6813062429428101) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.477549284696579) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4143700450658798) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5347775220870972) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.06767288595438004) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400544703006744) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.4308469146490097) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5092711746692657) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.10309367999434471) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.42986324429512024) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.011927980929613113) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186675310135) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5962875783443451) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.316741943359375) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (averageDuration_2 <= -0.40066154301166534) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6635134220123291) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.45369045436382294) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.252274326980114) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.2816295474767685) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7266050279140472) { - if (averageDuration_2 <= -0.5566121339797974) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107351958751678) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606539070606) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.7094330191612244) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3368610441684723) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3445131182670593) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6385188698768616) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5960135459899902) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (averageDuration_2 <= -0.6073680222034454) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.3374057561159134) { - if (averageDuration_2 <= -0.6791125535964966) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6555702686309814) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6413910686969757) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07195151224732399) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.35522042214870453) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3807809203863144) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1838994361460209) { - if (averageDuration_2 <= -0.6342234015464783) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.24957452714443207) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (maxDuration_2 <= -0.43396466970443726) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5381674468517303) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6953891515731812) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.05951779894530773) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (maxDuration_2 <= -0.37669797241687775) { - if (maxDuration_2 <= -0.43521587550640106) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3639540523290634) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5326409637928009) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.27426286041736603) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.34191402792930603) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.4458917826414108) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6082741916179657) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0030868298490531743) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3829773813486099) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058830752968788) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3807242214679718) { - if (averageDuration_2 <= -0.3870433568954468) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.6156572103500366) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37306079268455505) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7490861415863037) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.330244243144989) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.33612529933452606) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3602338284254074) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.4206695258617401) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.19592706114053726) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.4018948972225189) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.43154850602149963) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1155618317425251) { - if (averageDuration_2 <= -0.572259247303009) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06071211397647858) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.01564787235110998) { - if (maxDuration_2 <= -0.2510637864470482) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.47222697734832764) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.4279359132051468) { - if (maxDuration_2 <= -0.49300433695316315) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.41974852979183197) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.598107099533081) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2427278533577919) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3297087997198105) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5438234806060791) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5239328145980835) { - if (maxDuration_2 <= -0.5626051127910614) { - if (averageDuration_2 <= -0.7148647606372833) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.590447872877121) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6709553301334381) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4070816785097122) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.44993625581264496) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.391630083322525) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.6912834048271179) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (averageDuration_2 <= -0.4088483601808548) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.08886208385229111) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5925875306129456) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (maxDuration_2 <= -0.5083319842815399) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.35775986313819885) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4711952954530716) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2941840589046478) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5504738688468933) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.41210000216960907) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.4416525363922119) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0789777934551239) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { - if (numDurations_2 <= -0.12976674735546112) { - if (maxDuration_2 <= -0.4678063988685608) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.04061266127973795) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4472324103116989) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6555571258068085) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.34748217463493347) { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.4100559651851654) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.6095859706401825) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5000573396682739) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - if (averageDuration_2 <= -0.6975497305393219) { - if (maxDuration_2 <= -0.6828142404556274) { - if (maxDuration_2 <= -0.7542589604854584) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.700643002986908) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.6399409472942352) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (averageDuration_2 <= -0.6642254889011383) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42756858468055725) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.614367663860321) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172387123108) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.6742609739303589) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (maxDuration_2 <= -0.553758442401886) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5281822979450226) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.40604346990585327) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5494554042816162) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6584278643131256) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.46818894147872925) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.01600167527794838) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7279769778251648) { - if (maxDuration_2 <= -0.2094743326306343) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.170930914580822) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2582723796367645) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5778598785400391) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4714936912059784) { - if (maxDuration_2 <= -0.36992570757865906) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.5642429888248444) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6778405904769897) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (maxDuration_2 <= -0.5181893110275269) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.3816138505935669) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.32011324167251587) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1854533702135086) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.24568882584571838) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.3937246799468994) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5466974377632141) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.536464512348175) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3319229334592819) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.4338659942150116) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (averageDuration_2 <= -0.5785888135433197) { - if (maxDuration_2 <= -0.5675082802772522) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.268677219748497) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4277891665697098) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.47503477334976196) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (averageDuration_2 <= -0.572611540555954) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5477648973464966) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.6135604381561279) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5900779068470001) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2688600420951843) { - if (averageDuration_2 <= -0.5204283595085144) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5393828749656677) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1613878384232521) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1798400655388832) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6078041791915894) { - if (averageDuration_2 <= -0.5489970743656158) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.25782211869955063) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.5195886194705963) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4512515366077423) { - if (maxDuration_2 <= -0.37135404348373413) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620584785938263) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6007876694202423) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.2672463357448578) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.11300480738282204) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.004863670794293284) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.19438471645116806) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (numDurations_2 <= 2.7159931659698486) { - if (maxDuration_2 <= -0.4430191069841385) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4221530854701996) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.6727392673492432) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.842471718788147) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.11044969316571951) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (averageDuration_2 <= -0.2608429938554764) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.033641671761870384) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2721599042415619) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (averageDuration_2 <= -0.6125730276107788) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4767304062843323) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.11044968664646149) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (averageDuration_2 <= -0.1767900437116623) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.44919373095035553) { - if (maxDuration_2 <= -0.5613007545471191) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.10508787631988525) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9074200093746185) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239523053169) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2837759405374527) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9901047646999359) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0682660341262817) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2163441851735115) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.906676322221756) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.3239317834377289) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.2927061915397644) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.26925601065158844) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5094412565231323) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (averageDuration_2 <= -0.23828575015068054) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.19115804135799408) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.21616746485233307) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.3871554285287857) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.665979266166687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.579567551612854) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4474821835756302) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5366528332233429) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (maxDuration_2 <= -0.5057031214237213) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.392794594168663) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.6275711953639984) { - if (averageDuration_2 <= -0.6559590399265289) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7214200794696808) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08328690379858017) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0784654021263123) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5877139270305634) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.16673003137111664) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4025792181491852) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.2150450497865677) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.6270575225353241) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.34413181245326996) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8296964168548584) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.4720006436109543) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.45055627822875977) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.18484122306108475) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - if (maxDuration_2 <= -0.33969278633594513) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.7617704272270203) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6711086630821228) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5343524217605591) { - if (averageDuration_2 <= -0.4998858720064163) { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5960211753845215) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2581060528755188) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.35267578065395355) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.5018715858459473) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.44012220203876495) { - if (maxDuration_2 <= -0.6486711502075195) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.06571878865361214) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.04898570477962494) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.7946025133132935) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7550370395183563) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2621278613805771) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6370247900485992) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.28558778762817383) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.08094102516770363) { - if (maxDuration_2 <= -0.5303766131401062) { - if (averageDuration_2 <= -0.5438317954540253) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2595761716365814) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.07090604677796364) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.021090074442327023) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3657643347978592) { - if (averageDuration_2 <= -0.5320875942707062) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6902958750724792) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.32123707234859467) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.024194462224841118) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5868276953697205) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.739741712808609) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (averageDuration_2 <= -0.5182605385780334) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21980562806129456) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.036989739164710045) { - if (averageDuration_2 <= -0.5966008603572845) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.35888415575027466) { - if (averageDuration_2 <= -0.643396258354187) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3355884402990341) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06001227721571922) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1409154310822487) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4425361007452011) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.24444666504859924) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (maxDuration_2 <= -0.36216023564338684) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.37922661006450653) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.4357266277074814) { - if (averageDuration_2 <= -0.5775186419487) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.38081102073192596) { - if (maxDuration_2 <= -0.5711554288864136) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (maxDuration_2 <= -0.33815787732601166) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0849049799144268) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.6564563512802124) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (maxDuration_2 <= -0.4514883756637573) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2961706221103668) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (averageDuration_2 <= -0.3613964319229126) { - if (averageDuration_2 <= -0.5418146252632141) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.10393516346812248) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.0620607640594244) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.6286424100399017) { - if (maxDuration_2 <= -0.6853621900081635) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5553404688835144) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06623053550720215) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6437544524669647) { - if (averageDuration_2 <= -0.6896811425685883) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6052533686161041) { - if (maxDuration_2 <= -0.6761102676391602) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.46444711089134216) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7385323941707611) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.05159341171383858) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.20521094650030136) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.46684595942497253) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (numDurations_2 <= 6.415480613708496) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5115936994552612) { - if (averageDuration_2 <= -0.5521532595157623) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.44664424657821655) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2622973173856735) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.037421513348817825) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2778159976005554) { - if (averageDuration_2 <= -0.5787172019481659) { - if (maxDuration_2 <= -0.5880028903484344) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9917370676994324) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5603117048740387) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.14540570229291916) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.417084276676178) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.002271471719723195) { - if (averageDuration_2 <= -0.4696533530950546) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6409636735916138) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3494008481502533) { - if (averageDuration_2 <= -0.5885285437107086) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5721043944358826) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.014292513951659203) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.03808201104402542) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - if (averageDuration_2 <= -0.3874456286430359) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.41481491923332214) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09638939797878265) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.11780998483300209) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.4384583383798599) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (averageDuration_2 <= -0.6362746953964233) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5665238499641418) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26830294728279114) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.44997090101242065) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0009006254840642214) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2190776988863945) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.02006736770272255) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.08691485226154327) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.12777741998434067) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5167746245861053) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.39400604367256165) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.26201753318309784) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.31058867275714874) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4645035117864609) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.46429693698883057) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.36785009503364563) { - if (averageDuration_2 <= -0.5766976177692413) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4858788698911667) { - if (maxDuration_2 <= -0.6100626289844513) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (averageDuration_2 <= -0.6592468023300171) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6565076410770416) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.5002553462982178) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.5439257919788361) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (maxDuration_2 <= -0.5685215294361115) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.016184553503990173) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.19475125521421432) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.14846592396497726) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15156816691160202) { - if (maxDuration_2 <= -0.5501189231872559) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (averageDuration_2 <= -0.6909684836864471) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.030633222311735153) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (averageDuration_2 <= -0.5145505964756012) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.10413570702075958) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.017127064522355795) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13329769670963287) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.024194464087486267) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (maxDuration_2 <= -0.3275230824947357) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08422081917524338) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0761001892387867) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.42709319293498993) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2384834811091423) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.4711695462465286) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1938801109790802) { - if (averageDuration_2 <= -0.5716152489185333) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2029411792755127) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5037308931350708) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.00383871141821146) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6405423581600189) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620310544968) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2856951951980591) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6067191958427429) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1135147251188755) { - if (maxDuration_2 <= -0.4321385622024536) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6734523177146912) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6098056435585022) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4051479548215866) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09415304660797119) { - if (averageDuration_2 <= -0.5231500566005707) { - if (maxDuration_2 <= -0.48908616602420807) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.015389776788651943) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5329292118549347) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.5890832543373108) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13458647578954697) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (averageDuration_2 <= -0.627736359834671) { - if (numDurations_2 <= 6.13090455532074) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.35789404809474945) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2279456928372383) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5948984920978546) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1695406138896942) { - if (averageDuration_2 <= -0.3964981287717819) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12222980335354805) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.48460327088832855) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2669837027788162) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (averageDuration_2 <= -0.3028763234615326) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.3655228763818741) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.04324875585734844) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5998486578464508) { - if (averageDuration_2 <= -0.4220292568206787) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.024110945872962475) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08181719854474068) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.39840173721313477) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.14458885788917542) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.16259515285491943) { - if (averageDuration_2 <= -0.5329953134059906) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48120370507240295) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.40954066812992096) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597728431224823) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.5742352902889252) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.30490411818027496) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.4038868546485901) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5030182898044586) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6649013757705688) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4029061496257782) { - if (averageDuration_2 <= -0.401882067322731) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2946203202009201) { - if (maxDuration_2 <= -0.49771758913993835) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4577980041503906) { - if (averageDuration_2 <= -0.4480356276035309) { - if (maxDuration_2 <= -0.47275274991989136) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (averageDuration_2 <= -0.6368124485015869) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.572639673948288) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2916236072778702) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - if (maxDuration_2 <= -0.2805873602628708) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541474819183) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.2693729996681213) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404551506042) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - if (maxDuration_2 <= -0.6950142681598663) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28805598616600037) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.49122045934200287) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.04185870848596096) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6419226229190826) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6470335423946381) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.1516360640525818) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6789924502372742) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.015015913872048259) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4128846228122711) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.34566009044647217) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.15272027999162674) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9142167568206787) { - if (maxDuration_2 <= -0.3554309606552124) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.26742714643478394) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (maxDuration_2 <= -0.33801865577697754) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4940330237150192) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4132893681526184) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.7311380207538605) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.14812824875116348) { - if (averageDuration_2 <= -0.5781367123126984) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.03422987461090088) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5935510396957397) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.46902066469192505) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.49560022354125977) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 1.2931132316589355) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.623184859752655) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1371224895119667) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11718219891190529) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.31149403750896454) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.37020328640937805) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.08024165034294128) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (maxDuration_2 <= -0.6338092684745789) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744439005851746) { - if (maxDuration_2 <= -0.374144971370697) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.07610019110143185) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (averageDuration_2 <= -0.33539286255836487) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7049064338207245) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6383807063102722) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 0.7239611893892288) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.3005373626947403) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.35788053274154663) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.575544685125351) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.25935156643390656) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4452284276485443) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4789285510778427) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7512213289737701) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7542689442634583) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5737413465976715) { - if (maxDuration_2 <= -0.482759490609169) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6155956089496613) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.4726017415523529) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5564692914485931) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4761110693216324) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.49777135252952576) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { - if (maxDuration_2 <= -0.31172432750463486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (averageDuration_2 <= -0.6697492599487305) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.6210143864154816) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (averageDuration_2 <= -0.4282228648662567) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.17337137460708618) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.6282018423080444) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.27106189727783203) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.3464677184820175) { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.6764321029186249) { - if (maxDuration_2 <= -0.7053755521774292) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.6093282997608185) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.16962024569511414) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.581450879573822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.129171907901764) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6802070140838623) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.5344770848751068) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.325662225484848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.18521414697170258) { - if (numDurations_2 <= -0.6989187151193619) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4876602739095688) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.43547120690345764) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.057664165273308754) { - if (averageDuration_2 <= -0.49211832880973816) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (averageDuration_2 <= -0.6956366002559662) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3588019162416458) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.6209022700786591) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4070816785097122) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.8833414316177368) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.544114351272583) { - if (averageDuration_2 <= -0.3913480341434479) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (maxDuration_2 <= -0.6970532834529877) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.35665421187877655) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2944568395614624) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2971375286579132) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.7020067870616913) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4603101760149002) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.45012256503105164) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2707738131284714) { - if (maxDuration_2 <= -0.7486161291599274) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12442409247159958) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.8631931245326996) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.5640234649181366) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.5086512267589569) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.23199841380119324) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (maxDuration_2 <= -0.6432662904262543) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015798807144) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4628477990627289) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.08515290357172489) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6461068987846375) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.1498548611998558) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6260631680488586) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.9485477358102798) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2561350241303444) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (maxDuration_2 <= -0.3928362876176834) { - if (maxDuration_2 <= -0.39352773129940033) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37085163593292236) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0482568144798279) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.20400377362966537) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.16399110853672028) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.263237863779068) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.3462238162755966) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.06704606674611568) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2150970920920372) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.06135031580924988) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4219494462013245) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (maxDuration_2 <= -0.23174943774938583) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0020591020584106) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.0774097442626953) { - if (maxDuration_2 <= -0.3818267434835434) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.49859820306301117) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.05177287291735411) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9794953167438507) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (maxDuration_2 <= -0.3376590311527252) { - if (averageDuration_2 <= -0.6083321273326874) { - if (averageDuration_2 <= -0.665192037820816) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.7017943561077118) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.5871392786502838) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3802126497030258) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9802378714084625) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5472888648509979) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.2788807153701782) { - if (averageDuration_2 <= -0.5075477063655853) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2609674781560898) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6879418194293976) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7822611629962921) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6728918254375458) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (averageDuration_2 <= -0.6162255108356476) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32162290811538696) { - if (averageDuration_2 <= -0.5548312962055206) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.1968777179718018) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0135681629180908) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.304485559463501) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.60867977142334) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.48292990028858185) { - if (averageDuration_2 <= -0.4962081164121628) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3941240906715393) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.20299670100212097) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4027926921844482) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32479988038539886) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7550370395183563) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (averageDuration_2 <= -0.2988421469926834) { - if (maxDuration_2 <= -0.7058844566345215) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.9040391147136688) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.1562942266464233) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6658270061016083) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -5.2091405391693115) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5903565883636475) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5541948974132538) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6616465747356415) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.3351440578699112) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.265440344810486) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.14685963094234467) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.739947646856308) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0033265510573983192) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4544153958559036) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6878706216812134) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.38558030128479) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.016184553503990173) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.49702271819114685) { - if (averageDuration_2 <= -0.17363857477903366) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0919133834540844) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5462964177131653) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.227171003818512) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2663988620042801) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9773139953613281) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9766207337379456) { - if (averageDuration_2 <= -0.6290794909000397) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1660279557108879) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2826306819915771) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6754916608333588) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.3219284117221832) { - if (numDurations_2 <= 0.43938523530960083) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5202487111091614) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6598967909812927) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (maxDuration_2 <= -0.616695910692215) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5848664939403534) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.795640379190445) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.91457799077034) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5497745871543884) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.5486096143722534) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.573926568031311) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8966876864433289) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6721392720937729) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.312289834022522) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.06420418247580528) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5555276572704315) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6134804487228394) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.0620607640594244) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.002244919538498) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 1.5776891708374023) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3222681134939194) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5274057388305664) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.385944604873657) { - if (averageDuration_2 <= -0.40215201675891876) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.3846283257007599) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17287343740463257) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744439005851746) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.13254066184163094) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0673220781609416) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.17611654847860336) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5272400677204132) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.7237207889556885) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.4865536093711853) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2931492328643799) { - if (averageDuration_2 <= -0.5599842667579651) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5535230040550232) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.22954900562763214) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614850878715515) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.63819819688797) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.05177287291735411) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4740087240934372) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614684581756592) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5169931650161743) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4467995762825012) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (maxDuration_2 <= -0.6377780437469482) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6436245739459991) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.6710196137428284) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.4972262531518936) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (averageDuration_2 <= -0.5405691564083099) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.42958447337150574) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6592608392238617) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4424368143081665) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4301568269729614) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.6503072082996368) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.5046433508396149) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615730047225952) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.6310891807079315) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.462371289730072) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6782723069190979) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.3127615451812744) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21941764652729034) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.32608775794506073) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.902929961681366) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.641698569059372) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -5.2091405391693115) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5813411176204681) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.02006736770272255) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3610436916351318) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0641183853149414) { - if (averageDuration_2 <= -0.5865824818611145) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.508173018693924) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17320384085178375) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5615793466567993) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096855916082859) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2640686184167862) { - if (averageDuration_2 <= -0.6069186627864838) { - if (averageDuration_2 <= -0.6855879724025726) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.5218642354011536) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4761110842227936) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 1.2931131720542908) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8369036614894867) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4628353714942932) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 1.293113186955452) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1085416674613953) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5567216873168945) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.056986391544342) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - if (maxDuration_2 <= -0.5636104643344879) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.1968777179718018) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.5319747030735016) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615075588226318) { - if (averageDuration_2 <= -0.6808962821960449) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.351614311337471) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6054674386978149) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.10893140360713005) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.4015178084373474) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614977836608887) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4787839651107788) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.462165117263794) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617830514907837) { - if (maxDuration_2 <= -0.4910465031862259) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5145916938781738) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4686397910118103) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.16116946190595627) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.4992072731256485) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.5706000626087189) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.08108561113476753) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12788648158311844) { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.23600031435489655) { - if (averageDuration_2 <= -0.42968253791332245) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6487915813922882) { - if (averageDuration_2 <= -0.4606994390487671) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676986515522) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.4381866306066513) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5651591718196869) { - if (averageDuration_2 <= -0.47095203399658203) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6998036801815033) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.38320714235305786) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.592125415802002) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (maxDuration_2 <= -0.20241829007863998) { - if (averageDuration_2 <= -0.24866830557584763) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6617604494094849) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.3630341440439224) { - if (averageDuration_2 <= -0.30623771250247955) { - if (maxDuration_2 <= -0.46328045427799225) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.27994371950626373) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.44931818544864655) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.575957715511322) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.20027821511030197) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5018746107816696) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581474900245667) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.29195816814899445) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.18144676834344864) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3319229334592819) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.07104289624840021) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.4637082368135452) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (maxDuration_2 <= -0.44950273633003235) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.30005913972854614) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.36732906103134155) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.3245236277580261) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.33579234778881073) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.31918296217918396) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.3215075731277466) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3046439588069916) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.40452656149864197) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.16960474103689194) { - if (averageDuration_2 <= -0.34044039249420166) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.20192205905914307) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.467544361948967) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.4192776083946228) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21545574814081192) { - if (maxDuration_2 <= -0.395708292722702) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.3953486680984497) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461483120918274) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3388783782720566) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616110920906067) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.8376701474189758) { - if (maxDuration_2 <= -0.37811627984046936) { - if (averageDuration_2 <= -0.3325899839401245) { - if (maxDuration_2 <= -0.5060120522975922) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1613166406750679) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.48433348536491394) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.14496919512748718) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2675982862710953) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5143053084611893) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5070698261260986) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4451569616794586) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3247508108615875) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.3267330527305603) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.43168850243091583) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7001699805259705) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (maxDuration_2 <= -0.1361098736524582) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7089749723672867) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5039820671081543) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (averageDuration_2 <= -0.3366616368293762) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.11954253911972046) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (maxDuration_2 <= -0.2872660458087921) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22695939242839813) { - if (averageDuration_2 <= -0.2723873108625412) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5861169695854187) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22482605278491974) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.08823974430561066) { - if (maxDuration_2 <= -0.42012348771095276) { - if (averageDuration_2 <= -0.39200618863105774) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.23545221984386444) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4355650544166565) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.44009384512901306) { - if (maxDuration_2 <= -0.5560302138328552) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5405048429965973) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12205103412270546) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (averageDuration_2 <= -0.4649752229452133) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.24163713306188583) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3992937356233597) { - if (averageDuration_2 <= -0.44988226890563965) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.498771011829376) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4537514448165894) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12860267609357834) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0610276535153389) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.3317403793334961) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.4926325976848602) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.11044968664646149) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6218551099300385) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.3630237877368927) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.4692044109106064) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.02705236431211233) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.158935070037842) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.43052513897418976) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.14146148413419724) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.08752968162298203) { - if (averageDuration_2 <= -0.25115394592285156) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5947653651237488) { - if (averageDuration_2 <= -0.2880716472864151) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.02563363965600729) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.03612884506583214) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9901047646999359) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.03195782192051411) { - if (maxDuration_2 <= -0.414655476808548) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.31835752725601196) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.26042115688323975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (maxDuration_2 <= -0.3478759527206421) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.2857853025197983) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06723587587475777) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.06767288595438004) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7181889414787292) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4624513983726501) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (averageDuration_2 <= -0.327970415353775) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.06209924444556236) { - if (maxDuration_2 <= -0.2608882039785385) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.2533431351184845) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.03297067899256945) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4625188708305359) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619706869125366) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.1548214629292488) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7910511195659637) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2022019475698471) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.20183028280735016) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.133637934923172) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.28573258221149445) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.17566553503274918) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.8782627880573273) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.34538060426712036) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.33260439336299896) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4939395934343338) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.37209606170654297) { - if (averageDuration_2 <= -0.38668692111968994) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.20557653158903122) { - if (averageDuration_2 <= -0.3239855617284775) { - if (maxDuration_2 <= -0.3913673460483551) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8004021048545837) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.13283959031105042) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { - if (maxDuration_2 <= -0.097704216837883) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.18511583656072617) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (maxDuration_2 <= -0.03207954578101635) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.005164512665942311) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6319258213043213) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.08908027783036232) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.17377524822950363) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101411759853363) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.08880427852272987) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3512573093175888) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.817373812198639) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.15780750662088394) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2081424444913864) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.06957807019352913) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.08057339489459991) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.1149076297879219) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.07919298484921455) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7810593545436859) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.0670135747641325) { - if (averageDuration_2 <= -0.12391439452767372) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.31092672049999237) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.09241478890180588) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.272525817155838) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.04642844200134277) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.24378187954425812) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (maxDuration_2 <= -0.19998186081647873) { - if (averageDuration_2 <= -0.3265655040740967) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4516839385032654) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0880381129682064) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4610746502876282) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.14972051233053207) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (maxDuration_2 <= -0.24571456760168076) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.46206933259964) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.3500363379716873) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.3620873689651489) { - if (maxDuration_2 <= -0.36422449350357056) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.18870143964886665) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.458945631980896) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3806348592042923) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4457266926765442) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.36545784771442413) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.5274463593959808) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4621739387512207) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.002336133737117052) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.016886228695511818) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.008951388765126467) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.28224873542785645) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618827104568481) { - if (maxDuration_2 <= -0.23088077455759048) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (averageDuration_2 <= -0.3530452996492386) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.4803053140640259) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4383077621459961) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.34703555703163147) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.399466797709465) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349805697799) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (maxDuration_2 <= -0.10156898945569992) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.2734299898147583) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.3548585772514343) { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5182549059391022) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.134098768234253) { - if (numDurations_2 <= -1.2680706679821014) { - if (averageDuration_2 <= -0.25587642192840576) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1105085015296936) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3507310301065445) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (averageDuration_2 <= -0.3638581931591034) { - if (averageDuration_2 <= -0.5945302546024323) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.04716023989021778) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.02442827634513378) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9324439167976379) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6982278227806091) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.3393375277519226) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5058281123638153) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.35581547021865845) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5944485664367676) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0108682513237) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239523053169) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962230682373) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.3505582809448242) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { - if (averageDuration_2 <= -0.280603364109993) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.8431501388549805) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4985969066619873) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.15357730910182) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2710246294736862) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6765203177928925) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9963940978050232) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (maxDuration_2 <= -0.42488741874694824) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8922096788883209) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6042692065238953) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.267133891582489) { - if (averageDuration_2 <= -0.6121794879436493) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13135281950235367) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.33336856961250305) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.31709517538547516) { - if (averageDuration_2 <= -0.22163303196430206) { - if (maxDuration_2 <= -0.7867180407047272) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7523416876792908) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4046890139579773) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.17491016536951065) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2768465876579285) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6546749770641327) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= -1.837222695350647) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.391487717628479) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1921786293387413) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0659884661436081) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2735682129859924) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6038977801799774) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3243325352668762) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423399567604065) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.23214195668697357) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383228063583374) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.5533455610275269) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3310830742120743) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.5778491795063019) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7945892810821533) { - if (numDurations_2 <= -1.2680706679821014) { - if (averageDuration_2 <= -0.6597628593444824) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5405685305595398) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.40377911925315857) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5377740263938904) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0350375175476074) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5055360049009323) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.169767379760742) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.450542688369751) { - if (maxDuration_2 <= -0.8071745336055756) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.331823706626892) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.19193264842033386) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (averageDuration_2 <= -0.4964972585439682) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.288207232952118) { - if (maxDuration_2 <= -0.6658883094787598) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2658315896987915) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8512656986713409) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4112731069326401) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616687893867493) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4265463203191757) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.5636334717273712) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.49994249641895294) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.30781081318855286) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2867637202143669) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3989070057868958) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6172186732292175) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3836328983306885) { - if (averageDuration_2 <= -0.2099199965596199) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { - if (averageDuration_2 <= -0.28552646934986115) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5432513803243637) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9521841108798981) { - if (maxDuration_2 <= -0.5517271757125854) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4325028657913208) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.6057874858379364) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.9133753776550293) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.4659019261598587) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2323182821273804) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5734217464923859) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.365778848528862) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185136318207) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8407496511936188) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5140326768159866) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3523290157318115) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5362549722194672) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.4774004966020584) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.0461134016513824) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2398325353860855) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.4617381989955902) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.19073880463838577) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.6593423187732697) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5517847239971161) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5438568294048309) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.14034344255924225) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638475418091) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= -0.12976674735546112) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5323268175125122) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.583568811416626) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.28729744255542755) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6700160503387451) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.043788161128759384) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2972073554992676) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.01509860623627901) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4232270121574402) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.608759045600891) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.25021812319755554) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.20484384149312973) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - if (maxDuration_2 <= -0.7431860566139221) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - if (averageDuration_2 <= -0.7248823642730713) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.10391195863485336) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (averageDuration_2 <= -0.7160037457942963) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.06895928457379341) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9100004732608795) { - if (maxDuration_2 <= -0.607324868440628) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.26627956330776215) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7185845673084259) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1882456541061401) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.7692575454711914) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18572206795215607) { - if (averageDuration_2 <= -0.694722592830658) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4322318136692047) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6827129423618317) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09681638330221176) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.6803655922412872) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.953968048095703) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2221699953079224) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6944425702095032) { - if (averageDuration_2 <= -0.6869252324104309) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2934001013636589) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5572963654994965) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.34018470346927643) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3770712018013) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.16689516603946686) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.35340602695941925) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - if (maxDuration_2 <= -0.49999450147151947) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2607707679271698) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6999391615390778) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (maxDuration_2 <= -0.5999420881271362) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15067999809980392) { - if (averageDuration_2 <= -0.6925711929798126) { - if (maxDuration_2 <= -0.5475203692913055) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9465168714523315) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9320310056209564) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07249876484274864) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07749751955270767) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7552779018878937) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6596881449222565) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9412945806980133) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.6916144788265228) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6731037795543671) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.16803248971700668) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.6941227912902832) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4576177597045898) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3186089396476746) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= -0.12976674735546112) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0696258544921875) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (maxDuration_2 <= -0.7031948566436768) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9943352341651917) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9475547671318054) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.667253613471985) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.45206883549690247) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.691427707672119) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.39341557025909424) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17556529492139816) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5531649589538574) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.806822419166565) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.0620607640594244) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7751853168010712) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.4205806255340576) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4978967308998108) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.7180695235729218) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.6604251563549042) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3480091989040375) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.5893377363681793) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8929756581783295) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.6702350974082947) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.40980756282806396) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.11556170508265495) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2551909387111664) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.674978256225586) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1235536336898804) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6783157289028168) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4847381114959717) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1746509075164795) { - if (averageDuration_2 <= -0.3418702036142349) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3330533653497696) { - if (averageDuration_2 <= -0.4378347396850586) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (averageDuration_2 <= -0.48403574526309967) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1771579012274742) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.36549247801303864) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.011927980929613113) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.573576807975769) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3772287368774414) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.48083724081516266) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9386163651943207) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (averageDuration_2 <= -0.512138694524765) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3464781194925308) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (averageDuration_2 <= -0.4949798285961151) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3792107105255127) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3673401474952698) { - if (averageDuration_2 <= -0.426854208111763) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3723486661911011) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.7768075168132782) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.191345691680908) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6237106025218964) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.8985591232776642) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3074347525835037) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9473568499088287) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3246987760066986) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8645730912685394) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.23980845510959625) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.3349531292915344) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6272096931934357) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.39591944217681885) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.43380169570446014) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6031866371631622) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.46839161217212677) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.47169697284698486) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07709202542901039) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (averageDuration_2 <= -0.5867889523506165) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5102053880691528) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5986437499523163) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7293791770935059) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6724004149436951) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.633156806230545) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5239104926586151) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.10655908659100533) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5206049382686615) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.8759267926216125) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.43542414903640747) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (maxDuration_2 <= -0.6447048187255859) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4615861773490906) { - if (maxDuration_2 <= -0.4679052531719208) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.20855501294136047) { - if (maxDuration_2 <= -0.36115720868110657) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07741343975067139) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.622288852930069) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6198905408382416) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.27863624691963196) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.129419207572937) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.45393383502960205) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7017142474651337) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.0055207312107086) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3231467604637146) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17158154398202896) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5518099963665009) { - if (averageDuration_2 <= -0.44130007922649384) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3641948103904724) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.23541665077209473) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.30503928661346436) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.05582339130342007) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4187195301055908) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.272508144378662) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9075219631195068) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.23875661939382553) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5612537264823914) { - if (maxDuration_2 <= -0.6481466889381409) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8286791443824768) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.512716144323349) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.20340383797883987) { - if (averageDuration_2 <= -0.6282304227352142) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17432929575443268) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.347255527973175) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.05756162106990814) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7457694411277771) { - if (averageDuration_2 <= -0.4230099022388458) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.2951493263244629) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5011331886053085) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.005760632222518325) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.4341909885406494) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18017614632844925) { - if (averageDuration_2 <= -0.5140837728977203) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239316046238) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7363114953041077) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.628716230392456) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.4762915074825287) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6027591526508331) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6133553385734558) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7900744080543518) { - if (maxDuration_2 <= -0.3918865770101547) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5133978128433228) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.4174046963453293) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4504803568124771) { - if (averageDuration_2 <= -0.649158388376236) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.3595845401287079) { - if (maxDuration_2 <= -0.47594401240348816) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5447709262371063) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5068272948265076) { - if (averageDuration_2 <= -0.444750040769577) { - if (maxDuration_2 <= -0.37288887798786163) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.5697040855884552) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6945921778678894) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (averageDuration_2 <= -0.6175153255462646) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.43874116241931915) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.175313949584961) { - if (averageDuration_2 <= -0.4089609980583191) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 1.0085371732711792) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.44852638244628906) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.441428005695343) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.42463284730911255) { - if (maxDuration_2 <= -0.4167777746915817) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.970554769039154) { - if (maxDuration_2 <= -0.566708117723465) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.8869194984436035) { - if (averageDuration_2 <= -0.6144526302814484) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.669124722480774) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995391011238) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.4899631440639496) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6264811456203461) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.45871417224407196) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0938825011253357) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { - if (numDurations_2 <= 1.293113186955452) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.4465599060058594) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.7028251886367798) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (averageDuration_2 <= -0.5957594811916351) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (averageDuration_2 <= -0.6167005002498627) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1136469841003418) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.505833238363266) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7394025921821594) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3166049122810364) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.6270146667957306) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (maxDuration_2 <= -0.35865503549575806) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.1641088724136353) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4109825491905212) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4283345937728882) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7422342300415039) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5870160460472107) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3543576002120972) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.47987426817417145) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.05885088071227074) { - if (averageDuration_2 <= -0.48612749576568604) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.11957653984427452) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.40805475413799286) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1161888241767883) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.29787254333496094) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.24027340859174728) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.4869600981473923) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.6375917196273804) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09240681305527687) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5144076347351074) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3177255690097809) { - if (averageDuration_2 <= -0.6097465753555298) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22023065388202667) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17764408141374588) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (averageDuration_2 <= -0.36393165588378906) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.45310428738594055) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300742030143738) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7317712008953094) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.3801068663597107) { - if (averageDuration_2 <= -0.6358152031898499) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9725026190280914) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3639540523290634) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.649664044380188) { - if (averageDuration_2 <= -0.6521216332912445) { - if (maxDuration_2 <= -0.6609571874141693) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.453486144542694) { - if (maxDuration_2 <= -0.5398513972759247) { - if (numDurations_2 <= 0.43938523530960083) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1100372076034546) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.15560470521450043) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5335374176502228) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.39695706963539124) { - if (maxDuration_2 <= -0.5349963009357452) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.14793510735034943) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831730857491) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.509160190820694) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.21411364525556564) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.33914391696453094) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5348511636257172) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.002418522723019123) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1252724528312683) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.40006212890148163) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.185367189347744) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { - if (maxDuration_2 <= -0.36860598623752594) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1612241044640541) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.37663717567920685) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19786427170038223) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.3586145043373108) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1437944993376732) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.2450234219431877) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5674866437911987) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.10678848624229431) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2498842217028141) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6401868760585785) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17098986357450485) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8814854323863983) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.37748217582702637) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3896859586238861) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5481086671352386) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5220586657524109) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0761001892387867) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514857307076) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - if (averageDuration_2 <= -0.3247050493955612) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.1016435623168945) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.45751993358135223) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.930047035217285) { - if (averageDuration_2 <= -0.22815407812595367) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.5744280219078064) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6816835999488831) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.33297407627105713) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.024240282364189625) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.4362252652645111) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0474050045013428) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.4408155679702759) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (averageDuration_2 <= -0.2973327189683914) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4837825298309326) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5602551400661469) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.2628356069326401) { - if (averageDuration_2 <= -0.6116115748882294) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.19876184314489365) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - if (maxDuration_2 <= -0.41573184728622437) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12945043295621872) { - if (maxDuration_2 <= -0.5006453990936279) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (averageDuration_2 <= -0.49204806983470917) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461716651916504) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.04575827158987522) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5935895144939423) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354000866413) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3703129440546036) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.05089460453018546) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.49198848009109497) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4538646638393402) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.009550269693136215) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.33539047837257385) { - if (maxDuration_2 <= -0.4628601521253586) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - if (maxDuration_2 <= -0.4766075313091278) { - if (maxDuration_2 <= -0.4830254763364792) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1518705040216446) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.09995615109801292) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (averageDuration_2 <= -0.3433626890182495) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.47222697734832764) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (maxDuration_2 <= -0.4050920158624649) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15956388413906097) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.4264480769634247) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4033556133508682) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2081424444913864) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.23255515098571777) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22818587720394135) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.390465646982193) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.3279203027486801) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1279069259762764) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (averageDuration_2 <= -0.4124225527048111) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.01179838180542) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5609096884727478) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.1058387756347656) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.5328789353370667) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.3991781324148178) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3829228281974792) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9378973245620728) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0932992100715637) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2898950576782227) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6225845217704773) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0303162336349487) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.48643945157527924) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.122105896472931) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.2841893434524536) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5255602300167084) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4567950963974) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.015857099555432796) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615945219993591) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (cpuCoreIdleTimesPercentage_0_2 <= -3.1456851959228516) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4622765183448792) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.6090040504932404) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.04053129628300667) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (averageDuration_2 <= -0.5215466320514679) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.5704615414142609) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.013742357492447) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2961706221103668) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.202949285507202) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.16084395349025726) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4337121397256851) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.5138507783412933) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0862745642662048) { - if (averageDuration_2 <= -0.6358433365821838) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (averageDuration_2 <= -0.5112983882427216) { - if (averageDuration_2 <= -0.5548934638500214) { - if (averageDuration_2 <= -0.6181179583072662) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5378026068210602) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.43065008521080017) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.45184531807899475) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2176324725151062) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05154583975672722) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.55894535779953) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4543010890483856) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5723122954368591) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4610678553581238) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614049196243286) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.19699878990650177) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618456363677979) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (maxDuration_2 <= -0.5592417418956757) { - if (averageDuration_2 <= -0.4958396553993225) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.23776903003454208) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.43083733320236206) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4597458839416504) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5292026102542877) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4070816785097122) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6124353408813477) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835479974747) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.45525266230106354) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.377344086766243) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1966893076896667) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619110226631165) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615740180015564) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3015437722206116) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.9634567499160767) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0755597352981567) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617742896080017) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.0371131300926208) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.8542970418930054) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7900325655937195) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8454530239105225) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5649160146713257) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6050421595573425) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.1083666682243347) { - if (maxDuration_2 <= -0.5916727781295776) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1988589763641357) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.5298675298690796) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1523914337158203) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.6144105568528175) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.4482031911611557) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1578196287155151) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - if (averageDuration_2 <= -0.392337366938591) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.947862297296524) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617674350738525) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.425231397151947) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.03793227206915617) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.47810696065425873) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4139087200164795) { - if (maxDuration_2 <= -0.45589274168014526) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7890188694000244) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0653088167309761) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614469408988953) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615974426269531) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615896344184875) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.3064554929733276) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.4061783403158188) { - if (averageDuration_2 <= -0.37558428943157196) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.19196250289678574) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9716857671737671) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.22592103481292725) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (maxDuration_2 <= -0.4199994206428528) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3406248241662979) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4498900175094604) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.3772648572921753) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1785793900489807) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3633742928504944) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461083471775055) { - if (averageDuration_2 <= -0.5000107735395432) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4555639624595642) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.4182137995958328) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461818277835846) { - if (averageDuration_2 <= -0.3874751329421997) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8219747841358185) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.09628749452531338) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2558033913373947) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3819584399461746) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2829601541161537) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.4240894019603729) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617498517036438) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.5005238791927695) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.4107474386692047) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3721015453338623) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5349827706813812) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5572963654994965) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.47839054465293884) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.6088183522224426) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7177000939846039) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.35093338787555695) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2844176292419434) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.35311898589134216) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.39208416640758514) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8987681567668915) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (averageDuration_2 <= -0.3000231236219406) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2012681365013123) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (maxDuration_2 <= -0.4180871546268463) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.44734987616539) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4093968272209167) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (averageDuration_2 <= -0.27266135811805725) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1599007844924927) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4885703772306442) { - if (averageDuration_2 <= -0.29641111195087433) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.035209111170843244) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4422590136528015) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.3051094561815262) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4507312774658203) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.23984725028276443) { - if (maxDuration_2 <= -0.4499964565038681) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7805559635162354) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4872463494539261) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617215394973755) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615954756736755) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615554213523865) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4545214176177979) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.3095976561307907) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1201142780482769) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4473835229873657) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (averageDuration_2 <= -0.28475847840309143) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9446793794631958) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.448905110359192) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.4052489250898361) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.25084976851940155) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6028887629508972) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.09518700838089) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.8930988311767578) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.8228538036346436) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.27381955832242966) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - if (averageDuration_2 <= 0.018134440295398235) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3194934129714966) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3533165752887726) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.7111433446407318) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= -1.837222695350647) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.31374046206474304) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.517324686050415) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3224862813949585) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2944737672805786) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.8547589480876923) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2214270234107971) { - if (averageDuration_2 <= 0.1397598832845688) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.296149730682373) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2659074664115906) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7107703685760498) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6790503561496735) { - if (maxDuration_2 <= -0.25680792331695557) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 0.07440219447016716) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.2526112049818039) { - if (averageDuration_2 <= -0.05853019282221794) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.338785767555237) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6469157338142395) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.148527979850769) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6678047180175781) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6219379305839539) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7134260833263397) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1255253180861473) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.0805900394916534) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4614522159099579) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4630298614501953) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (averageDuration_2 <= -0.2724656015634537) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.450217366218567) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.17435260117053986) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13100546598434448) { - if (averageDuration_2 <= -0.43089108169078827) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5109862238168716) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22038308531045914) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2274562492966652) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.23199841380119324) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1104446053504944) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21713721007108688) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8789362609386444) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7861332893371582) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9653382301330566) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.23011482506990433) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.08210491389036179) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3861694931983948) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.47222697734832764) { - if (maxDuration_2 <= -0.22111208736896515) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3339366316795349) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.12110622972249985) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5054148137569427) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.6049301624298096) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.053722286596894264) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.030183885246515274) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (maxDuration_2 <= -0.0834856890141964) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.741899698972702) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (averageDuration_2 <= -0.5247022211551666) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.40397731959819794) { - if (averageDuration_2 <= -0.6370089948177338) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.14633847028017044) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0319364666938782) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9912260174751282) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.24124965071678162) { - if (maxDuration_2 <= -0.039269763976335526) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5116555094718933) { - if (averageDuration_2 <= -0.5341428816318512) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2933339923620224) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.325233593583107) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7595236897468567) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3949257582426071) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (averageDuration_2 <= -0.2447378933429718) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.272434338927269) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.23568308353424072) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09926561452448368) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.22893311083316803) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345905259251595) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4966981112957001) { - if (maxDuration_2 <= -0.28517140448093414) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.2649085074663162) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12636230140924454) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1391429752111435) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4735252261161804) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3962622284889221) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - if (averageDuration_2 <= -0.20003663003444672) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17955081909894943) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.23426517099142075) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.32659387588500977) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.39409829676151276) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.11538991704583168) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15699292719364166) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2616274952888489) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.23410074412822723) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.19660581648349762) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.3399337828159332) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6022156476974487) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.13361117616295815) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.28817401826381683) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.398678258061409) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1641283594071865) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7385323941707611) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.21613691002130508) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.37633463740348816) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.21888645738363266) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (maxDuration_2 <= -0.15703501552343369) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0619677305221558) { - if (maxDuration_2 <= -0.19411609321832657) { - if (averageDuration_2 <= -0.32283158600330353) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (maxDuration_2 <= -0.31465210020542145) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7165998220443726) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.17296283692121506) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0705103874206543) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4290362745523453) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07478025183081627) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9115525186061859) { - if (maxDuration_2 <= -0.25204138457775116) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.6517910659313202) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.40493257343769073) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1730526089668274) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.533584326505661) { - if (maxDuration_2 <= -0.30819128453731537) { - if (maxDuration_2 <= -0.31663520634174347) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1641283594071865) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.07104289624840021) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.14689862728118896) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.2253367006778717) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.36239226162433624) { - if (maxDuration_2 <= -0.2880309522151947) { - if (averageDuration_2 <= -0.33100661635398865) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (averageDuration_2 <= -0.34384599328041077) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.35519394278526306) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461520254611969) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.018933151848614216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612388610839844) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5140326619148254) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.34608781337738037) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4484865516424179) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (maxDuration_2 <= -0.2596343457698822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.880715936422348) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.01621931977570057) { - if (averageDuration_2 <= -0.5576055645942688) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0279210209846497) { - if (maxDuration_2 <= -0.3417240381240845) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.24201448261737823) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.27366068959236145) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089094400406) { - if (averageDuration_2 <= -0.4112266004085541) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2208606600761414) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7950571775436401) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.8165296912193298) { - if (averageDuration_2 <= -0.330180361866951) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.272406741976738) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.3633762449026108) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.20011864602565765) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.222715735435486) { - if (maxDuration_2 <= -0.3232835829257965) { - if (maxDuration_2 <= -0.33270250260829926) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8881430327892303) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619784951210022) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6649061441421509) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (maxDuration_2 <= -0.30399955809116364) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.955045759677887) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4113122522830963) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.32344405353069305) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1340287327766418) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8434671759605408) { - if (maxDuration_2 <= -0.34620437026023865) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0360899567604065) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8849446773529053) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.44634944200515747) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.49420349299907684) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3940853029489517) { - if (averageDuration_2 <= -0.25718414783477783) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5491228699684143) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5274609625339508) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3197579085826874) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.033405440859496593) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.14118413627147675) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.28058217465877533) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.28234250843524933) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (maxDuration_2 <= -0.32595036923885345) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.28076185286045074) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.03482109773904085) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.20322178304195404) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.41251610219478607) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.3314919173717499) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5054936110973358) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4740087389945984) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5143053084611893) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2226475179195404) { - if (averageDuration_2 <= -0.26614169776439667) { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.2798497676849365) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (averageDuration_2 <= -0.2695035934448242) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.2607783079147339) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7267124354839325) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4608479738235474) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2075033113360405) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.2662852853536606) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (maxDuration_2 <= -0.22071188688278198) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3159213364124298) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5332335531711578) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.22192628681659698) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.2761172503232956) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.27592048048973083) { - if (maxDuration_2 <= -0.23805337399244308) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.22337881475687027) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618201851844788) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.23688071966171265) { - if (maxDuration_2 <= -0.3253728449344635) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9149197340011597) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.2059846669435501) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8632377088069916) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.272525817155838) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.546418309211731) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.3281007409095764) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (averageDuration_2 <= -0.21085462719202042) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616687297821045) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.36268191039562225) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6742686331272125) { - if (averageDuration_2 <= -0.20897146314382553) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8814854323863983) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9773394763469696) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9246130585670471) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.053654758259654045) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5199229717254639) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.043676257133484) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6200047135353088) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513206481933594) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.33706134557724) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7641547620296478) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (maxDuration_2 <= -0.28351520001888275) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (averageDuration_2 <= -0.3108229786157608) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (maxDuration_2 <= -0.28711916506290436) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.23212911933660507) { - if (maxDuration_2 <= -0.2653885930776596) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0769655853509903) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.142924666404724) { - if (maxDuration_2 <= -0.33834294974803925) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.850790411233902) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.3424205332994461) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9533257186412811) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5376587510108948) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.19444938749074936) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5190798342227936) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.24758196622133255) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.2643298953771591) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (maxDuration_2 <= -0.3120182156562805) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6790743172168732) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.0015177130699158) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4611186385154724) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.2825992107391357) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3006844520568848) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.2966272830963135) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5039710998535156) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5978890359401703) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6772676110267639) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.056516630575060844) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.38820597529411316) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.121818721294403) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.24461983144283295) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4976775497198105) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4479955583810806) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (averageDuration_2 <= -0.5690076947212219) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.12697963416576385) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9125380516052246) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.01814319472759962) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4284423440694809) { - if (maxDuration_2 <= -0.17209433764219284) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.48471736907959) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= -0.12976674735546112) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.088798999786377) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.22159480303525925) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2929857075214386) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7443138360977173) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.6040880978107452) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.2751609832048416) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.27451182901859283) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.543830007314682) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8745182156562805) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.04753599129617214) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4170562028884888) { - if (cpuCoreIdleTimesPercentage_0_2 <= -3.0378661155700684) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2081424482166767) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.16009339690208435) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612905979156494) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3180261254310608) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.02247861074283719) { - if (averageDuration_2 <= -0.4724709689617157) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2534714937210083) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09222996234893799) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.27601249516010284) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.719666987657547) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5401298105716705) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.31061840057373047) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.29809047281742096) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.09862838312983513) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6495670080184937) { - if (maxDuration_2 <= -0.16719868779182434) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5304866433143616) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - if (averageDuration_2 <= -0.18548375368118286) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.29344412684440613) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5134530961513519) { - if (averageDuration_2 <= -0.5381163656711578) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (averageDuration_2 <= -0.4759577661752701) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6658473610877991) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.17640001326799393) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4658149480819702) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.17726998776197433) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1743083968758583) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.03256593085825443) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.17875602096319199) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613726735115051) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (averageDuration_2 <= -0.6234489381313324) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.12524712830781937) { - if (averageDuration_2 <= -0.24189632385969162) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.16471368074417114) { - if (maxDuration_2 <= -0.15773403644561768) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.541467308998108) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.3762378543615341) { - if (averageDuration_2 <= -0.3766048103570938) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.853185385465622) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.373752474784851) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.13502199947834015) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.212310314178467) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111741781235) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.4931783229112625) { - if (averageDuration_2 <= -0.5068649351596832) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -3.1672489643096924) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.1817498877644539) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (averageDuration_2 <= -0.2322753593325615) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.33120138943195343) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.35249628126621246) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4632027745246887) { - if (maxDuration_2 <= -0.1661374866962433) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4443861246109009) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5568251311779022) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.47463560104370117) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4761110693216324) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4620898962020874) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.47202688455581665) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.37259049713611603) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09167009592056274) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5391761660575867) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6542955935001373) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.8759267926216125) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2889665365219116) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (averageDuration_2 <= -0.24759628623723984) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6678047180175781) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8785081505775452) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3675816059112549) { - if (averageDuration_2 <= -0.35455358028411865) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.093022644519806) { - if (averageDuration_2 <= -0.5506995320320129) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8984744846820831) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1747518852353096) { - if (maxDuration_2 <= -0.19668171554803848) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.34018470346927643) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.06866029649972916) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597728431224823) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0394643247127533) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.28351762890815735) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5958105623722076) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4743887931108475) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5529657304286957) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.014614461921155453) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.3099656403064728) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.018933151848614216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5808907449245453) { - if (averageDuration_2 <= -0.6117734014987946) { - if (averageDuration_2 <= -0.6993576884269714) { - if (maxDuration_2 <= -0.25316329300403595) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3025229573249817) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2574550360441208) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4908469915390015) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2325873300433159) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2479664087295532) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0039320229552686214) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.3255345225334167) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (maxDuration_2 <= -0.1874096915125847) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.306581974029541) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5163620114326477) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736663818359375) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.6376422047615051) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.274852991104126) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4451114982366562) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (maxDuration_2 <= -0.2820182889699936) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.345740869641304) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404551506042) { - if (maxDuration_2 <= -0.06974821165204048) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2684081345796585) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.967336505651474) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4778141975402832) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.772266983985901) { - if (maxDuration_2 <= -0.16478516906499863) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4619466662406921) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.5414674282073975) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.463708221912384) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5324616432189941) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4415391683578491) { - if (averageDuration_2 <= -0.297176256775856) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.18925846368074417) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.1222290992736816) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.842471718788147) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5334058403968811) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20583121478557587) { - if (maxDuration_2 <= -0.1401723548769951) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654292166233063) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0100053548812866) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606539070606) { - if (maxDuration_2 <= -0.22920402884483337) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7036527991294861) { - if (cpuCoreIdleTimesPercentage_0_2 <= -3.0163023471832275) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.462061583995819) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.4813380241394043) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4178837537765503) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8595393002033234) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.40310265123844147) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - if (maxDuration_2 <= -0.34348413348197937) { - if (averageDuration_2 <= -0.2924409359693527) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.2427998036146164) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.1787833273410797) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - if (maxDuration_2 <= -0.33751721680164337) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.10897934809327126) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (averageDuration_2 <= -0.3148110955953598) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.13277872279286385) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091154009103775) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (averageDuration_2 <= -0.22320546209812164) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.410847783088684) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.044591041281819344) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612124562263489) { - if (cpuCoreIdleTimesPercentage_0_2 <= -3.1888128519058228) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - if (maxDuration_2 <= -0.21882259100675583) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8042240738868713) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (averageDuration_2 <= -0.2645341157913208) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4498792886734009) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4774925112724304) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.207729160785675) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.459603190422058) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5215785503387451) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4251258969306946) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.009034345857799053) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18255729973316193) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.13578222692012787) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.268459975719452) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.06169711425900459) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8548007607460022) { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.12043766677379608) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5141507685184479) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4913126528263092) { - if (maxDuration_2 <= -0.09624028950929642) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.19914613664150238) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.43678878247737885) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2505628392100334) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.2378152534365654) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.19619394838809967) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.030472377315163612) { - if (averageDuration_2 <= -0.10769497975707054) { - if (averageDuration_2 <= -0.15477293729782104) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.4205805659294128) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8365260660648346) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2954769432544708) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13605600595474243) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.26047688722610474) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.07508211582899094) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1505725085735321) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.07319875061511993) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060375809669495) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.25132977217435837) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6941463351249695) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { - if (numDurations_2 <= 1.5776891708374023) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.539885550737381) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5493299961090088) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.065772533416748) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.05668957531452179) { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.19351089000701904) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.04092031344771385) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7622863054275513) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.03905022796243429) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8175609409809113) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.28748664259910583) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.28893762826919556) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.98470401763916) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.1686907336115837) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3510195314884186) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.757363885641098) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.977627694606781) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.07460862025618553) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -3.011645793914795) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.542745441198349) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (numDurations_2 <= 1.5776891708374023) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.04202357120811939) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.07433109730482101) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (maxDuration_2 <= -0.16729485988616943) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.021669305860996246) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.818825900554657) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4623234272003174) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.402473509311676) { - if (numDurations_2 <= 3.8542970418930054) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.2730184681713581) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.32002659142017365) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1811463236808777) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3268954753875732) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - if (maxDuration_2 <= -0.16798125207424164) { - if (averageDuration_2 <= -0.1315850242972374) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3713851571083069) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.03894988261163235) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7361017763614655) { - if (averageDuration_2 <= -0.17046784609556198) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.18244300782680511) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.05030343495309353) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2315274253487587) { - if (maxDuration_2 <= -0.15809118747711182) { - if (maxDuration_2 <= -0.23226862400770187) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.37348559498786926) { - if (cpuCoreIdleTimesPercentage_0_2 <= -3.1456851959228516) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.13557962328195572) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (maxDuration_2 <= -0.14387769252061844) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5494690537452698) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.04377059452235699) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0795602202415466) { - if (maxDuration_2 <= -0.25501224398612976) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7096761763095856) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.627981036901474) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7725633382797241) { - if (averageDuration_2 <= -0.17408805340528488) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8901151120662689) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3738009035587311) { - if (maxDuration_2 <= -0.24569443613290787) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2276285886764526) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.115374207496643) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4109545946121216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.26836518943309784) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07532546296715736) { - if (averageDuration_2 <= -0.607037365436554) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19844172149896622) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7980000674724579) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.7264435887336731) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - if (maxDuration_2 <= -0.6447985768318176) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2788488268852234) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0245378017425537) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - if (averageDuration_2 <= -0.6758981049060822) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.14831599220633507) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7658474445343018) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8233934342861176) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.11207352578639984) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17862650007009506) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.2158416286110878) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.628980278968811) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1355701982975006) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6467078328132629) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (maxDuration_2 <= -0.5214564800262451) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (averageDuration_2 <= -0.6196662187576294) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1915777176618576) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7090363204479218) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.6380235552787781) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.6714982688426971) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21390405297279358) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8822689652442932) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07629472762346268) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2010788694024086) { - if (maxDuration_2 <= -0.1464180126786232) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.22721769660711288) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.29343073070049286) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (averageDuration_2 <= -0.7000639140605927) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26463837921619415) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.894895315170288) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (averageDuration_2 <= -0.6375980973243713) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.1250547133386135) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.6928893625736237) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.265079602599144) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2201671451330185) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.661405622959137) { - if (averageDuration_2 <= -0.6678074598312378) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.770825207233429) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.12565887719392776) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.23575107753276825) { - if (averageDuration_2 <= -0.6474745571613312) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.8568262457847595) { - if (maxDuration_2 <= -0.6288401484489441) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1515476480126381) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.07104289624840021) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6612808704376221) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.5098477602005005) { - if (maxDuration_2 <= -0.5653150379657745) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2731640934944153) { - if (averageDuration_2 <= -0.5767695605754852) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0408272743225098) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2496701404452324) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0279672145843506) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9882237315177917) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.6474882364273071) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - if (averageDuration_2 <= -0.5276211798191071) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.5689947605133057) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13950705528259277) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (maxDuration_2 <= -0.09024034067988396) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5726988911628723) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (maxDuration_2 <= -0.5182474851608276) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.36447541415691376) { - if (maxDuration_2 <= -0.47984445095062256) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307503938674927) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (maxDuration_2 <= -0.3436690866947174) { - if (averageDuration_2 <= -0.4704529792070389) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9289629459381104) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4901038408279419) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - if (averageDuration_2 <= -0.4266274869441986) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.1602861285209656) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.39644569158554077) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.02020001411438) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (maxDuration_2 <= -0.2175765186548233) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37602217495441437) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6021405160427094) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.4268293082714081) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.07018454559147358) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7919865548610687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.436114177107811) { - if (maxDuration_2 <= -0.3326621353626251) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2471717968583107) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19543035328388214) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2873567044734955) { - if (numDurations_2 <= 3.8542970418930054) { - if (averageDuration_2 <= -0.39691442251205444) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11726292595267296) { - if (averageDuration_2 <= -0.6328580677509308) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.02542587649077177) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.945031225681305) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (numDurations_2 <= 2.715993046760559) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8881857991218567) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.02816903404891491) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2025655061006546) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (maxDuration_2 <= -0.27628423273563385) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9758899211883545) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.08445678278803825) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0655585490167141) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8854756653308868) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411147415638) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.2074223756790161) { - if (averageDuration_2 <= -0.46087510883808136) { - if (maxDuration_2 <= -0.6129247546195984) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (averageDuration_2 <= -0.6105188429355621) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (maxDuration_2 <= -0.6118102371692657) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (averageDuration_2 <= -0.5724523961544037) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7005680203437805) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.7111433446407318) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.1562942266464233) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.863446444272995) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3348832726478577) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.4576098918914795) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.3536808490753174) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.2928657680749893) { - if (maxDuration_2 <= -0.7248163819313049) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.43810851871967316) { - if (averageDuration_2 <= -0.6376657485961914) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.08563710004091263) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5500378012657166) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.81649512052536) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (averageDuration_2 <= -0.557155430316925) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.9711636304855347) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.2265063524246216) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.688724160194397) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22516443580389023) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4820135682821274) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.0827866643667221) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.313352346420288) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11326995864510536) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8234044313430786) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.847002923488617) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.319106325507164) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.3011098653078079) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2666581869125366) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.23562312126159668) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.129824660718441) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.525141566991806) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2591913193464279) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.12016559392213821) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (averageDuration_2 <= -0.2899358421564102) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620584785938263) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.20512349903583527) { - if (maxDuration_2 <= -0.33825160562992096) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9364436864852905) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.452235609292984) { - if (averageDuration_2 <= -0.5695056617259979) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4804098457098007) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4478062689304352) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6641151905059814) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.016020972281694412) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.5970219075679779) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2503814622759819) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9198275804519653) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2582220286130905) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7121440172195435) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.05089460453018546) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4424658641219139) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - if (maxDuration_2 <= -0.7163598835468292) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8571887016296387) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5509451329708099) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.1881877183914185) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0094910860061646) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.4033753871917725) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5331827402114868) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.7573455572128296) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.350558340549469) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.9150264263153076) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3819319605827332) { - if (averageDuration_2 <= -0.40911445021629333) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.625324845314026) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2133159041404724) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7019365727901459) { - if (averageDuration_2 <= -0.5991204679012299) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2536173462867737) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6588824391365051) { - if (averageDuration_2 <= -0.5385065674781799) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.32132817804813385) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6033362746238708) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7181000113487244) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.590578556060791) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 0.43938523530960083) { - if (maxDuration_2 <= -0.6715058386325836) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.061080813407898) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5882075130939484) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.1049726009368896) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.5445163249969482) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.46005986630916595) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.4184123277664185) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9543364346027374) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.05251327343285084) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8226003646850586) { - if (maxDuration_2 <= -0.5809164941310883) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.48570142686367035) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1526985615491867) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6657903790473938) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.16826745122671127) { - if (maxDuration_2 <= -0.5010175406932831) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7894352376461029) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.358297884464264) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6414737403392792) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.625324845314026) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8942911028862) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.407070055603981) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.2788926362991333) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6951417922973633) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101411759853363) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.38957931101322174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.334647297859192) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3383114337921143) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.590038001537323) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7766198515892029) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6916195452213287) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1320453882217407) { - if (averageDuration_2 <= -0.2782624065876007) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.628485083580017) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.29119522869586945) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.01113498210907) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3315422981977463) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6516931354999542) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7188244760036469) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (numDurations_2 <= -1.837222695350647) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.334991455078125) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.545235812664032) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8401204347610474) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.44763000309467316) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962230682373) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.3216712921857834) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.034652352333069) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461464524269104) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8922342658042908) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (maxDuration_2 <= -0.5868657529354095) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239316046238) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.42392972111701965) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615544080734253) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614967703819275) { - if (averageDuration_2 <= -0.5306451916694641) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.1982994377613068) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (maxDuration_2 <= -0.5801111161708832) { - if (averageDuration_2 <= -0.6906363070011139) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.33930803835392) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618114233016968) { - if (averageDuration_2 <= -0.284215971827507) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617030024528503) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (averageDuration_2 <= -0.632073312997818) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.08030135557055473) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.779565453529358) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4447349309921265) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.34639835357666) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0140175819396973) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.0867060422897339) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.876897096633911) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744439005851746) { - if (maxDuration_2 <= -0.6343664228916168) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.3677852749824524) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.23838981986045837) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.5228671729564667) { - if (averageDuration_2 <= -0.3877088129520416) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3590235412120819) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618280529975891) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.5593884289264679) { - if (numDurations_2 <= 1.5776891708374023) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.188903570175171) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.18310410529375076) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5787403583526611) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0260339975357056) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.9766682386398315) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.3071071654558182) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5771068334579468) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5930547714233398) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9712387919425964) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6301410794258118) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.6343664824962616) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9844173192977905) { - if (maxDuration_2 <= -0.18542402237653732) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8636749386787415) { - if (maxDuration_2 <= -0.5203977823257446) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6387429684400558) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.2443223595619202) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28608767688274384) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5533960461616516) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9936091303825378) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9475547671318054) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.056148648262024) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.4271390736103058) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5774387121200562) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.14633847028017044) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.2505267709493637) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.4064226150512695) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4610571265220642) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5304918587207794) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.0371131300926208) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.5153095424175262) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (numDurations_2 <= 1.2931131720542908) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.36976155638694763) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.113007068634033) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.5206721425056458) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3099476099014282) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.919241189956665) { - if (maxDuration_2 <= -0.3174380362033844) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5713846385478973) { - if (maxDuration_2 <= -0.45502664148807526) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7936633825302124) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.17337136715650558) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.6088816523551941) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - if (maxDuration_2 <= -0.38161639869213104) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4712699353694916) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6380131840705872) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.3151870518922806) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8180266320705414) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.33012063801288605) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4257570058107376) { - if (cpuCoreIdleTimesPercentage_7_2 <= -4.679832100868225) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7010758370161057) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.794986069202423) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6351950466632843) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.668535977602005) { - if (averageDuration_2 <= -0.4468124955892563) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6344201862812042) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.43319031596183777) { - if (averageDuration_2 <= -0.5056062042713165) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6139990091323853) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7450112402439117) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0832464694976807) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.796681821346283) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.6176962852478027) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.654976725578308) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.011162791401147842) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7893766164779663) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (maxDuration_2 <= -0.44604550302028656) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.3743445873260498) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0739621818065643) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3023143857717514) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6267630457878113) { - if (averageDuration_2 <= -0.4564829170703888) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5411526560783386) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5697179436683655) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619218707084656) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4639639258384705) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.30472269654273987) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3473442792892456) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.31854650378227234) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7960012555122375) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.700783371925354) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.39081817865371704) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.16811807453632355) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48550011217594147) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.5503170490264893) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1315871477127075) { - if (numDurations_2 <= 1.008537232875824) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5816194415092468) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8439178466796875) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.816646009683609) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (maxDuration_2 <= -0.18679672479629517) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11588183045387268) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6142922937870026) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617440104484558) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3066533207893372) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3369972705841064) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (maxDuration_2 <= -0.406484991312027) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0016361474990845) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.47940488159656525) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.453476905822754) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6696322858333588) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.061045942828059196) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06579532101750374) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4611685276031494) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.2663294672966003) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5426492094993591) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.38106584548950195) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3868193030357361) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.3313126415014267) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612310528755188) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.418724000453949) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6883209347724915) { - if (numDurations_2 <= 6.700057029724121) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.2680702209472656) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.9130818843841553) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0926077365875244) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2703052759170532) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5975099205970764) { - if (averageDuration_2 <= -0.5132721364498138) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3550577312707901) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.44848693907260895) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618417024612427) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.501266896724701) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.080111026763916) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.185534358024597) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (maxDuration_2 <= -0.512303352355957) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9317080974578857) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.699253499507904) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4540174603462219) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6765041947364807) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6355568766593933) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.47871604561805725) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.443142294883728) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07867522723972797) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6881247162818909) { - if (averageDuration_2 <= -0.6056359112262726) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.272525817155838) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.21801240742206573) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6837410926818848) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6835466623306274) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 4.4234490394592285) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615778923034668) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461376667022705) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2004525363445282) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.256256103515625) { - if (numDurations_2 <= -0.6989187151193619) { - if (averageDuration_2 <= -0.5324789583683014) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.048086049035191536) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8483448028564453) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6431209444999695) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.1273745819926262) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7373865842819214) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5087015628814697) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.2841893434524536) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.6281538009643555) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.5853307247161865) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4622921347618103) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.5486994981765747) { - if (maxDuration_2 <= -0.1698252335190773) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1251400709152222) { - if (maxDuration_2 <= -0.6437981426715851) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37816889584064484) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.5885316133499146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4551496505737305) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613531827926636) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.9393047094345093) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.050012111663818) { - if (maxDuration_2 <= -0.15419330447912216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.31715817749500275) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= -1.837222695350647) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2935070395469666) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (averageDuration_2 <= -0.6678782105445862) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8927212059497833) { - if (averageDuration_2 <= -0.4939402639865875) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795464992523) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (averageDuration_2 <= -0.3147253841161728) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.02006736770272255) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006180226802826) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8186551034450531) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.800664186477661) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.27993708848953247) { - if (averageDuration_2 <= -0.4538297951221466) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.39163969457149506) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8394768834114075) { - if (averageDuration_2 <= -0.40059448778629303) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1036253571510315) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9819967150688171) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (maxDuration_2 <= -0.5427032113075256) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4611616730690002) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.098084568977356) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.014206530526280403) { - if (averageDuration_2 <= -0.636952668428421) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (averageDuration_2 <= -0.6880501508712769) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9303662180900574) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2914080023765564) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.6869477033615112) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (maxDuration_2 <= -0.23257765173912048) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8981298208236694) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.18870143964886665) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.12558414041996002) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5738900005817413) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.5338109135627747) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15049386769533157) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6172495484352112) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.042088031768799) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.07682698452845216) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.156949996948242) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.6048632264137268) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4761110693216324) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5296398103237152) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.016195381991565228) { - if (averageDuration_2 <= -0.629343569278717) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5984353125095367) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8143409490585327) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (averageDuration_2 <= -0.5418438613414764) { - if (maxDuration_2 <= -0.6308180093765259) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (maxDuration_2 <= -0.5308350324630737) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.013676952105015516) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.6202227473258972) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.003230966569390148) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (averageDuration_2 <= -0.6046774983406067) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5792258977890015) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= -0.22390571236610413) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9074200093746185) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7296390533447266) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8247008323669434) { - if (maxDuration_2 <= -0.19773801416158676) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7399566471576691) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.3262604475021362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.056736469268799) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.39914655685424805) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4056227505207062) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8089635968208313) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.21955451369285583) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.476896196603775) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768865585327) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.010589920450001955) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8097683191299438) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5087048709392548) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615349173545837) { - if (numDurations_2 <= 2.7159931659698486) { - if (numDurations_2 <= 0.43938523530960083) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.923100084066391) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.34144285321235657) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.21123460680246353) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9690228700637817) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4621230959892273) { - if (averageDuration_2 <= -0.5072685480117798) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616071581840515) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.3828223794698715) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0673220781609416) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.5266422033309937) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.31560930609703064) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.1402511596679688) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.22836538031697273) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6124423146247864) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4246256351470947) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2010539546608925) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (maxDuration_2 <= -0.41373856365680695) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6398673951625824) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.485487461090088) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4561148136854172) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9764195084571838) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.509722590446472) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22281455248594284) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5841111093759537) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3319229334592819) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (maxDuration_2 <= -0.3898122310638428) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.9304614961147308) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8798241019248962) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461768388748169) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.011978268623352) { - if (maxDuration_2 <= -0.08942480012774467) { - if (averageDuration_2 <= -0.6878019571304321) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9181130826473236) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.627740889787674) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.40961697697639465) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.579987049102783) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11338623613119125) { - if (averageDuration_2 <= -0.6459107995033264) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9609633684158325) { - if (averageDuration_2 <= -0.7186458706855774) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11055562645196915) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.058868955820798874) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (maxDuration_2 <= -0.200521320104599) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4291780591011047) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.821343332529068) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - if (maxDuration_2 <= -0.2986934781074524) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.08906470239162445) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.04916457645595074) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.3108910322189331) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2250828742980957) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { - if (maxDuration_2 <= -0.666797548532486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9498692154884338) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (maxDuration_2 <= -0.25966985523700714) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (averageDuration_2 <= -0.6235432624816895) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (averageDuration_2 <= -0.6224396526813507) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6378272473812103) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.586611270904541) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.5609686970710754) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (maxDuration_2 <= -0.519057959318161) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5966320633888245) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8679518103599548) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21357513964176178) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (averageDuration_2 <= -0.6323291659355164) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.45117759704589844) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.970554769039154) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - if (averageDuration_2 <= -0.6181385219097137) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8014824390411377) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1641283594071865) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 4.4234490394592285) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4606603980064392) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4001330733299255) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6647417843341827) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0172709226608276) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22630078345537186) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7240342497825623) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.47814084589481354) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.17883510142564774) { - if (averageDuration_2 <= -0.6729955971240997) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.916710078716278) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.6335899829864502) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.3168049305677414) { - if (maxDuration_2 <= -0.4159294664859772) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.16312622278928757) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11933080106973648) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.23538777232170105) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.18245819956064224) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.683826923370361) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8347786962985992) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (maxDuration_2 <= -0.05908569507300854) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8488622307777405) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6972857117652893) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.4592611491680145) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3287367224693298) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4507088661193848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.3886016607284546) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (maxDuration_2 <= -0.4541349709033966) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5545796155929565) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7296634316444397) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4849693775177002) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616491794586182) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7787335515022278) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= -0.7061682045459747) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5987449586391449) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.23457122594118118) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615055918693542) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.026282787322998) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4582929611206055) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9287554323673248) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.16862349212169647) { - if (averageDuration_2 <= -0.6625210046768188) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.6447226405143738) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9334983229637146) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.536476343870163) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8466048836708069) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.32499878108501434) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6281251907348633) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.26058579981327057) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27069348096847534) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.28479087352752686) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.8504594564437866) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4600653648376465) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4986836612224579) { - if (numDurations_2 <= 4.4234490394592285) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614420533180237) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.9961256682872772) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5636332631111145) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (maxDuration_2 <= -0.472507119178772) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5545671880245209) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9081359207630157) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.883689045906067) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5994730889797211) { - if (numDurations_2 <= 3.8542970418930054) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1803824305534363) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5243768095970154) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.019699811935425) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6389344036579132) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.21253760159015656) { - if (numDurations_2 <= 3.8542970418930054) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6461068987846375) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.992276519536972) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32333701848983765) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.442237973213196) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.456537127494812) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8416776061058044) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7805819511413574) { - if (averageDuration_2 <= -0.5799857378005981) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5572963654994965) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.854166328907013) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7287027537822723) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.38945066928863525) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9627065658569336) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9730144739151) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13339687138795853) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8525102138519287) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1424911804497242) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0389721393585205) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.273147813975811) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.1345902755856514) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.149449348449707) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0108682513237) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.38592463731765747) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4608294367790222) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.2620986998081207) { - if (maxDuration_2 <= -0.4741002023220062) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6373211145401) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5783068239688873) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5400970131158829) { - if (maxDuration_2 <= -0.34009797871112823) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.4366424083709717) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.35893110930919647) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4009338766336441) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17016811668872833) { - if (averageDuration_2 <= -0.533677339553833) { - if (numDurations_2 <= 4.4234490394592285) { - if (maxDuration_2 <= -0.05760914273560047) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (numDurations_2 <= 3.8542970418930054) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.872537910938263) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (averageDuration_2 <= -0.5382843613624573) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (averageDuration_2 <= -0.5016792118549347) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575631141663) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.8542970418930054) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7664079666137695) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.56096875295043) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0761001892387867) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4395319819450378) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 5.199471950531006) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.2677568793296814) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.6617713570594788) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.273901879787445) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2975906580686569) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.6513705253601074) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7990553379058838) { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2215687707066536) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.0975579917430878) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.252526044845581) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2498842179775238) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13034740090370178) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1119801998138428) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09155382215976715) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9142167568206787) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9698109030723572) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3970448225736618) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.10875974968075752) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1916980743408203) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.10908609256148338) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.24885770678520203) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904514193535) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.2951493263244629) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.0005691051483154) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.432640314102173) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.266158938407898) { - if (maxDuration_2 <= -0.17317841202020645) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2411949038505554) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.14644820988178253) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0716551542282104) { - if (maxDuration_2 <= -0.2712797522544861) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6401868760585785) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8212940692901611) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.5074199438095093) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.1618149280548096) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5331338942050934) { - if (averageDuration_2 <= -0.22687120735645294) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.367729514837265) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.23222923278808594) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.45751993358135223) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5334058552980423) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.0545014007948339) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7650062441825867) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.887032389640808) { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.2588758319616318) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.4869600981473923) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7659831643104553) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - if (maxDuration_2 <= -0.2124149352312088) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0864598751068115) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.5744280219078064) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6947140097618103) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.15018897503614426) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.218908429145813) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.35311898589134216) { - if (averageDuration_2 <= -0.17097879201173782) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 4.143068313598633) { - if (averageDuration_2 <= 0.1063140258193016) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089094400406) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5306227803230286) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.14319629222154617) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.108508586883545) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4743780344724655) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.0446120500564575) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5472859442234039) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5438525080680847) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7892730832099915) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454916000366) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5100665390491486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.06111019663512707) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.4960829168558121) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4293491989374161) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6700903177261353) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (maxDuration_2 <= -0.031324757263064384) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.16305415332317352) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6757018864154816) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9380845427513123) { - if (averageDuration_2 <= -0.2033289298415184) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 5.691187381744385) { - if (maxDuration_2 <= -0.3383149206638336) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8759901523590088) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.18265940994024277) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.38419879972934723) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.521420031785965) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1772414892911911) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.28894054889678955) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.010329468408599496) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0752306766808033) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.142195701599121) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.31678687036037445) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.163061738014221) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8190291225910187) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5628749132156372) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4434279799461365) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.126781165599823) { - if (maxDuration_2 <= -0.20854999125003815) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.40810826420783997) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615368843078613) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 1.2931131720542908) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.146690845489502) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8579038381576538) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.29245805740356445) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (averageDuration_2 <= -0.17671193182468414) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665165930986404) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4622784852981567) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.3828223645687103) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (averageDuration_2 <= -0.16056165099143982) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.24346733838319778) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617801308631897) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8407304286956787) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.42058065533638) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09056577831506729) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3208264410495758) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461520254611969) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 1.008537232875824) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.007359815528616309) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (averageDuration_2 <= -0.20514479279518127) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (averageDuration_2 <= -0.13425371795892715) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617342352867126) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9708797335624695) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4633405804634094) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (numDurations_2 <= 2.1468411684036255) { - if (maxDuration_2 <= -0.1738419383764267) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.29960088431835175) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.17539717257022858) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.08158387616276741) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9616619348526) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.6133179664611816) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (averageDuration_2 <= -0.08819058537483215) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8585195541381836) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4620859622955322) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.391000747680664) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3642842769622803) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.769197106361389) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (averageDuration_2 <= 1.127707600593567) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.232879102230072) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.021375520154833794) { - if (maxDuration_2 <= 0.44858473539352417) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7460405826568604) { - if (maxDuration_2 <= 0.22034376114606857) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (averageDuration_2 <= -0.2703048884868622) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484130263328552) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3583451211452484) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.977935403585434) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.31374046206474304) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5335149466991425) { - if (numDurations_2 <= 1.008537232875824) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.49911367893219) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5719137787818909) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4494861662387848) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12650687247514725) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.9711636304855347) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.03794736601412296) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.5897117853164673) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= -0.026710317470133305) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.11218501627445221) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6946036219596863) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.19032950699329376) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4957520067691803) { - if (averageDuration_2 <= 0.11692098155617714) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.771731048822403) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.0927669070661068) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.42751912772655487) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9479746520519257) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (averageDuration_2 <= 0.09008290246129036) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.12046515569090843) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.2730184718966484) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.2848228812217712) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8858786523342133) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.34036800265312195) { - if (averageDuration_2 <= -0.11376642435789108) { - if (maxDuration_2 <= -0.01850185263901949) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.8759267926216125) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.681984543800354) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (averageDuration_2 <= -0.5759931206703186) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.13441523537039757) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5196825265884399) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - if (averageDuration_2 <= -0.4052688777446747) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485253512859344) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485326826572418) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.43701186776161194) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3160262405872345) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485814094543457) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118889793754) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - if (averageDuration_2 <= 0.5439204275608063) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.8431501388549805) { - if (averageDuration_2 <= -0.18931268155574799) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6789072453975677) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.023485160432755947) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7385323941707611) { - if (averageDuration_2 <= -0.15606769174337387) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.275984451174736) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40794865787029266) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4511452615261078) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291398823261261) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.30773666501045227) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.15591146796941757) { - if (averageDuration_2 <= -0.38356249034404755) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (maxDuration_2 <= 0.09950897097587585) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12833990901708603) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044531345367) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (averageDuration_2 <= -0.05590721219778061) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5335745513439178) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7481330335140228) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5256181955337524) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2759339064359665) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.07600072771310806) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7501570582389832) { - if (maxDuration_2 <= 0.323102667927742) { - if (averageDuration_2 <= -0.2706994265317917) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718024134635925) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9268515706062317) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5267339944839478) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0539959073066711) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.6609642505645752) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.48651473224163055) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7483929693698883) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2898607701063156) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 0.260788157582283) { - if (maxDuration_2 <= 0.23940204083919525) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9387838244438171) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7470153272151947) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (averageDuration_2 <= -0.0016553624300286174) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.30284979939460754) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 0.43938523530960083) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744438707828522) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9224752485752106) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.226507544517517) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 0.10446617007255554) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11939822137355804) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9593591094017029) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.33432537317276) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.48712749779224396) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.27817265689373016) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.3664710074663162) { - if (numDurations_2 <= 1.008537232875824) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.718052476644516) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0057842135429382) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7259543836116791) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7144536375999451) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21182775497436523) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.46677136421203613) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.31427889317274094) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4337436258792877) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3205748349428177) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5155184268951416) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.4456382989883423) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.2079158052802086) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.30120691657066345) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8961704969406128) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.045531051233410835) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (maxDuration_2 <= 0.11807874217629433) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23435544967651367) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6666222810745239) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.226507544517517) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.13358815014362335) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5863189101219177) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5283451676368713) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0582075715065002) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.12900003045797348) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4236430376768112) { - if (maxDuration_2 <= -0.0222046272829175) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1400299370288849) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6142241358757019) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9905251264572144) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606166541576) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.012466492597013712) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.20815537497401237) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.066078007221222) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5662574768066406) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.008512758184224367) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5653239488601685) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.16253018379211426) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.43927276134490967) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 0.43938523530960083) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - if (averageDuration_2 <= -0.10979708656668663) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (numDurations_2 <= 1.008537232875824) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.18707860261201859) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8514364659786224) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.45450422167778015) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404551506042) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7091420590877533) { - if (averageDuration_2 <= -0.2383028119802475) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4316047728061676) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7992309927940369) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.12550751864910126) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (maxDuration_2 <= -0.013213643804192543) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.19446878880262375) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5331178307533264) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8922097086906433) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0539959073066711) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.11133947968482971) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5851742923259735) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (averageDuration_2 <= 0.3801325857639313) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7619648277759552) { - if (averageDuration_2 <= -0.07871228829026222) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.6752995252609253) { - if (numMissedDeadlines_2 <= 0.4979674816131592) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.2595261335372925) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.24505255371332169) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5330264270305634) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9725194573402405) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3482784330844879) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - if (averageDuration_2 <= -0.07768546044826508) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.17088397592306137) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8279767632484436) { - if (averageDuration_2 <= -0.13079051673412323) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.04984685266390443) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.39584796130657196) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.204942524433136) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.906103253364563) { - if (numDurations_2 <= 1.5776891708374023) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118843227625) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.4205806255340576) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.41164593398571014) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5393894612789154) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7148667573928833) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8786169588565826) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.35649625957012177) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= 0.33451490104198456) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.07977671548724174) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.44840389490127563) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9278550744056702) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4172661155462265) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.05177287012338638) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736663818359375) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= -0.12976674735546112) { - if (maxDuration_2 <= 0.30672870576381683) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20013290643692017) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.17851174622774124) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4902231693267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3543576002120972) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.022966206073761) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040612459183) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07390185445547104) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.23117153346538544) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.702006757259369) { - if (maxDuration_2 <= 0.3560301810503006) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.13277871906757355) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.39395439624786377) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= 0.670403003692627) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7546965777873993) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4747615456581116) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 0.43938523530960083) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9120322167873383) { - if (maxDuration_2 <= 0.2409800961613655) { - if (numDurations_2 <= 0.43938523530960083) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.2929334044456482) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (averageDuration_2 <= -0.3023112267255783) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.16804800182580948) { - if (numDurations_2 <= 0.43938523530960083) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.20982589572668076) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7935594916343689) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5405782759189606) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27295316755771637) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (maxDuration_2 <= 0.1466171219944954) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.20230043679475784) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.0668092630803585) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7770294547080994) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (maxDuration_2 <= 0.22267382591962814) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.533350795507431) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.12221493571996689) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7230017483234406) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6139990389347076) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (numMissedDeadlines_2 <= 0.4979674816131592) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.35910236835479736) { - if (averageDuration_2 <= -0.23228463530540466) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5126733183860779) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.969329833984375) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8614085912704468) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.588534951210022) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5228553414344788) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4673050791025162) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.15532471984624863) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.17409542202949524) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.15728962421417236) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.03609041962772608) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.8303110599517822) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.19882531464099884) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.6053611040115356) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.08162709325551987) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1568768620491028) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8963220119476318) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.12607022374868393) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27688831090927124) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.12537280842661858) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7131112217903137) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.09877948462963104) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { - if (averageDuration_2 <= -0.09110592678189278) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7385323941707611) { - if (numDurations_2 <= -0.12976674735546112) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.2684951424598694) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1254468448460102) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.204942524433136) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7445935308933258) { - if (averageDuration_2 <= 0.20809295028448105) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2776985466480255) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.015873609576374292) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - if (averageDuration_2 <= 0.010482713347300887) { - if (maxDuration_2 <= 0.2979351580142975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5126439779996872) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05635959282517433) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.29589296877384186) { - if (averageDuration_2 <= -0.25956524163484573) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.8385125398635864) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.7158921957015991) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.7091822624206543) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.40491238236427307) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 1.008537232875824) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.029112407006323338) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= 0.008003653027117252) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6236535012722015) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.034113602712750435) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.08858705312013626) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.32487206161022186) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.22645554691553116) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.11221031844615936) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1048748679459095) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1828387826681137) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.33027519285678864) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.04490944929420948) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2425139918923378) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456615447998) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398807287216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 1.008537232875824) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5701518654823303) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.28870557248592377) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 1.5776891708374023) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - if (averageDuration_2 <= 0.12272057682275772) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.41405148804187775) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8023677170276642) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8481349349021912) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.23408861458301544) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= -1.837222695350647) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089243412018) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6013438403606415) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18487103283405304) { - if (averageDuration_2 <= 0.38395413756370544) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6461068987846375) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4920502007007599) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.39174915850162506) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.05637750402092934) { - if (maxDuration_2 <= 1.9776089787483215) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2517904192209244) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8706097602844238) { - if (averageDuration_2 <= -0.1930968463420868) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.8464657962322235) { - if (averageDuration_2 <= -0.2548300325870514) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.6095828413963318) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.14633847028017044) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (maxDuration_2 <= 0.6759397387504578) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028930187225342) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 0.35163094103336334) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5647778511047363) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= 0.04261348582804203) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.5832354724407196) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (maxDuration_2 <= 0.8502392470836639) { - if (averageDuration_2 <= -0.12602166831493378) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3378899097442627) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= -0.12976674735546112) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4795044809579849) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.33207377791404724) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 1.8622652292251587) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.6321735382080078) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3964366763830185) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5157051980495453) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.6338953971862793) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.6206255853176117) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6191380023956299) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6179587841033936) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.0774097442626953) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 0.43938523530960083) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3126780241727829) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.3381130695343018) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.04049695748835802) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.9565199613571167) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - if (maxDuration_2 <= 1.1037593483924866) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5393121540546417) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.1703981161117554) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.41048693656921387) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.9363716542720795) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.98851677775383) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.733877420425415) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7308622300624847) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (averageDuration_2 <= 0.0504826083779335) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484481930732727) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7485483288764954) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5978890359401703) { - if (averageDuration_2 <= -0.47143277525901794) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7058610022068024) { - if (averageDuration_2 <= 0.06334415450692177) { - if (maxDuration_2 <= 0.7302075922489166) { - if (averageDuration_2 <= -0.18529465794563293) { - if (maxDuration_2 <= 0.6953120231628418) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - if (averageDuration_2 <= 0.04929473903030157) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= 0.1273183897137642) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - if (numDurations_2 <= -0.12976674735546112) { - if (maxDuration_2 <= 0.6124829053878784) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2028830498456955) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 4.4234490394592285) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.31320442259311676) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -4.151602029800415) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8112029433250427) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484309077262878) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.508751779794693) { - if (averageDuration_2 <= -0.12054255604743958) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5512841641902924) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7447766661643982) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.6192526817321777) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.45268799364566803) { - if (maxDuration_2 <= 1.3366631865501404) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13679712265729904) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 0.6220437586307526) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (averageDuration_2 <= 0.3065025508403778) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - if (numDurations_2 <= -1.837222695350647) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 1.435962438583374) { - if (maxDuration_2 <= 0.7321374714374542) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.2848228812217712) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7550370395183563) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.7972663044929504) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8191148638725281) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.6892729997634888) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 0.33249492943286896) { - if (averageDuration_2 <= 0.25916415452957153) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.17430027574300766) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= 0.5466925799846649) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13084669411182404) { - if (averageDuration_2 <= 0.18569526821374893) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7210254371166229) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (averageDuration_2 <= 0.3479827791452408) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.18798432499170303) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= -0.12976674735546112) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2842828780412674) { - if (averageDuration_2 <= 0.2959175258874893) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6460579633712769) { - if (maxDuration_2 <= 1.4430540204048157) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.5566930770874023) { - if (maxDuration_2 <= 3.211769700050354) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.007237492129206657) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7455012202262878) { - if (numDurations_2 <= 1.008537232875824) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.2542518377304077) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.745991587638855) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 2.2415308952331543) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11062952503561974) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.51711505651474) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1707926988601685) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 0.42193692922592163) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5509213507175446) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3922964781522751) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.390332356095314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.2677568793296814) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.30061179399490356) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.008863927330821753) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.09443336725235) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3161342293024063) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0810039043426514) { - if (numDurations_2 <= 1.5776891708374023) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.173933207988739) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.3677852749824524) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2306938171386719) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8041383922100067) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.20388202369213104) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9142167568206787) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - if (numDurations_2 <= 1.5776891708374023) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { - if (maxDuration_2 <= 3.337059497833252) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.17179327458143234) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 2.6414151191711426) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.6415618658065796) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8963220119476318) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13095342740416527) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6390779614448547) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5836866199970245) { - if (averageDuration_2 <= -0.17834172397851944) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3949257582426071) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8423057794570923) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 1.5776891708374023) { - if (numDurations_2 <= 0.43938523530960083) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6361984312534332) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.13746867328882217) { - if (maxDuration_2 <= 0.6155371963977814) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (numDurations_2 <= 1.5776891708374023) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.46571849286556244) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.344773069024086) { - if (averageDuration_2 <= -0.24836672097444534) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.42405539751052856) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177308797836304) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.4580065608024597) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09480652958154678) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 6.886106014251709) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.43848101794719696) { - if (maxDuration_2 <= 5.924017429351807) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.40637898445129395) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8286791443824768) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (averageDuration_2 <= -0.3223971873521805) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (maxDuration_2 <= 1.2119837403297424) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592867255211) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.7185242176055908) { - if (numDurations_2 <= 0.43938523530960083) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 3.100911259651184) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8875992894172668) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6706474721431732) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18268565088510513) { - if (maxDuration_2 <= 0.7393201589584351) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 1.6309821605682373) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2201882600784302) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.5201438069343567) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 3.5850659608840942) { - if (numDurations_2 <= 3.8542970418930054) { - if (averageDuration_2 <= -0.31061211228370667) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.7633680999279022) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.23199840635061264) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9045552313327789) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.515501469373703) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5986413955688477) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7322549521923065) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8721798360347748) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7804926037788391) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.747398316860199) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= 0.4642040580511093) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 0.2583402693271637) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.777624100446701) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 5.826171636581421) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.590164065361023) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1612403467297554) { - if (averageDuration_2 <= -0.033431531861424446) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1858297921717167) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.1783012747764587) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09276749566197395) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= -0.6989187151193619) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.526071161031723) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3185248523950577) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.419750839471817) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05939977802336216) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.008437632117420435) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 1.0488834977149963) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3603290915489197) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0757729634642601) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.40191371738910675) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21233825385570526) { - if (averageDuration_2 <= 0.6666126549243927) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3264668583869934) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5378614962100983) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.8557784855365753) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7521025836467743) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.5744280219078064) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.870782196521759) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.506699800491333) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 1.6761149764060974) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6347606778144836) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.4736660569906235) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 0.43938523530960083) { - if (maxDuration_2 <= 1.2001611590385437) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1371594071388245) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.6982106566429138) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { - if (averageDuration_2 <= 0.650501549243927) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.7960829138755798) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.08600029349327087) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= -1.837222695350647) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.275539368391037) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= 0.6985235214233398) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2321552112698555) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.027943328022956848) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3949257582426071) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= 0.08602035045623779) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8632377088069916) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1272754669189453) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4932494163513184) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.25149397552013397) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7596176266670227) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1933276727795601) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.00044530520972330123) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4206101894378662) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9242295920848846) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.411447286605835) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20784858614206314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 2.2347483038902283) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.1678913831710815) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.012378409504890442) { - if (averageDuration_2 <= 0.24102335423231125) { - if (numDurations_2 <= 3.8542970418930054) { - if (maxDuration_2 <= 3.883361339569092) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0336969494819641) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - if (maxDuration_2 <= -0.016399614047259092) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5077577829360962) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8521566092967987) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3657059967517853) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.4184123277664185) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.9360241293907166) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { - if (numDurations_2 <= 1.5776891708374023) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5085129737854004) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.331823706626892) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4961337149143219) { - if (maxDuration_2 <= 0.3654137998819351) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3133798474445939) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0673220781609416) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 3.3992879390716553) { - if (averageDuration_2 <= 0.3995504826307297) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6373989880084991) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.373752474784851) { - if (maxDuration_2 <= 1.3425568342208862) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.6292269229888916) { - if (maxDuration_2 <= 0.3169380724430084) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999137312173843) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.5477566719055176) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0318717658519745) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.40207982063293457) { - if (maxDuration_2 <= 0.43722833693027496) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.6415618658065796) { - if (averageDuration_2 <= -0.16931356757413596) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4039691984653473) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= 0.18696018308401108) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6803672909736633) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.405732154846191) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 2.3888806104660034) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.07794856652617455) { - if (maxDuration_2 <= 2.1608113050460815) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.044527769088745) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.863024592399597) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.4059672355651855) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1173449754714966) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1051284968852997) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.938111960887909) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7513307929039001) { - if (maxDuration_2 <= 2.3169949054718018) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5111016929149628) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.03208610601723194) { - if (maxDuration_2 <= 0.45412634313106537) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= 1.4651947617530823) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.2490766644477844) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5542886853218079) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { - if (maxDuration_2 <= 0.2450222671031952) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3477352261543274) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9593592286109924) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - if (maxDuration_2 <= 0.009357767645269632) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.43328239023685455) { - if (averageDuration_2 <= -0.4358310103416443) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9738000631332397) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.014264244586229324) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.210843525826931) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= 0.12322219088673592) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7475498020648956) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1722413897514343) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9105602204799652) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0242519676685333) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (maxDuration_2 <= 2.1212406158447266) { - if (maxDuration_2 <= 0.0768008641898632) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8607339262962341) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.018952965736389) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485678493976593) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.740801215171814) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8599216341972351) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5336331725120544) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.1355241537094116) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.9812396168708801) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6487295627593994) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8951848447322845) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1532800197601318) { - if (averageDuration_2 <= 0.3574665039777756) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.6793462634086609) { - if (cpuCoreIdleTimesPercentage_7_2 <= -4.050901412963867) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.519687294960022) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.41048693656921387) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8963220119476318) { - if (averageDuration_2 <= 0.26596584916114807) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1161888241767883) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.01268397830426693) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3221363425254822) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.9133753776550293) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.3693881034851074) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.128469467163086) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 0.32696136832237244) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3763646483421326) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.016563892364502) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 1.507827639579773) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7480499446392059) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - if (maxDuration_2 <= 0.4199046641588211) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.472336232662201) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1321731805801392) { - if (maxDuration_2 <= 0.32185399532318115) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2217394709587097) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.9711636304855347) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0262272357940674) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8796047568321228) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.6652236878871918) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.4576098918914795) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17848403006792068) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 0.3681333214044571) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7550370395183563) { - if (averageDuration_2 <= -0.637970894575119) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1700569987297058) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.290977358818054) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.444263219833374) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.350590229034424) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9596558213233948) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8781578540802002) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7281722128391266) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0162522792816162) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8712836802005768) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.6967872381210327) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9958769381046295) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - if (maxDuration_2 <= 2.5329322814941406) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.886878728866577) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.454704999923706) { - if (maxDuration_2 <= 0.4597287029027939) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.20815634727478027) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3543576002120972) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5467133820056915) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= -1.837222695350647) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5567779839038849) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (averageDuration_2 <= 0.6449016332626343) { - if (averageDuration_2 <= 0.633177250623703) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.4340621829032898) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 1.3538119792938232) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3401797115802765) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.40457236766815186) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.2831013202667236) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 2.985949754714966) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2827761620283127) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.547249913215637) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (maxDuration_2 <= 0.8501431941986084) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { - if (cpuCoreIdleTimesPercentage_7_2 <= -4.050901412963867) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= -1.837222695350647) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8555848300457001) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.1537500619888306) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.8452296257019043) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.386396884918213) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3323505520820618) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0971235036849976) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.028396189212799) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.9797444343566895) { - if (maxDuration_2 <= 4.656016826629639) { - if (averageDuration_2 <= 0.2558552622795105) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4734087735414505) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 0.643548846244812) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.185565710067749) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 5.6706976890563965) { - if (maxDuration_2 <= 3.8263707160949707) { - if (averageDuration_2 <= 0.4018881171941757) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 3.625117778778076) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.516908645629883) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.4205806255340576) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6765446662902832) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.7946025133132935) { - if (maxDuration_2 <= 5.392617702484131) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.0422221422195435) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.754804491996765) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.12992041558027267) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.4643927812576294) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { - if (maxDuration_2 <= 4.266775369644165) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.319189190864563) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.2911977767944336) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 0.6862711310386658) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= 0.4006679654121399) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.30679476261138916) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8145439028739929) { - if (maxDuration_2 <= 5.111055850982666) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18521007895469666) { - if (maxDuration_2 <= 1.7629531621932983) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4005657136440277) { - if (averageDuration_2 <= -0.49008750915527344) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3916861116886139) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0902730822563171) { - if (averageDuration_2 <= -0.0711655430495739) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8303315341472626) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (averageDuration_2 <= -0.05755419284105301) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= -1.837222695350647) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5261990427970886) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= 0.002367605920881033) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5792979001998901) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 0.2882041484117508) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { - if (averageDuration_2 <= -0.11562366783618927) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.2349066287279129) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.14856670703738928) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.8837427794933319) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414793252945) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.27706578373908997) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.14856670051813126) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.9725836217403412) { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4329824149608612) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.09995615109801292) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7213721871376038) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3596280366182327) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6102865934371948) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (averageDuration_2 <= -0.02345554530620575) { - if (averageDuration_2 <= -0.3465505987405777) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6799042820930481) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4125160872936249) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.05006267502903938) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.212310314178467) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= -0.6989187151193619) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2977767884731293) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5940277874469757) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.42623719573020935) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5140326619148254) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.43208564817905426) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.43764111399650574) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (maxDuration_2 <= 0.5140042304992676) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.35503965616226196) { - if (maxDuration_2 <= 0.24061790853738785) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - if (maxDuration_2 <= 0.19049593806266785) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3323505520820618) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.39207449555397034) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.536476343870163) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - if (averageDuration_2 <= -0.01755179977044463) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.7064703106880188) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6749744713306427) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.24484729766845703) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5331178307533264) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.16723784804344177) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.3255345225334167) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.599466860294342) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.9953776597976685) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.2587443590164185) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.06953328102827072) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.36018379032611847) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4374353736639023) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (averageDuration_2 <= -0.0786764994263649) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 0.06748113315552473) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.17071663588285446) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.2023368775844574) { - if (maxDuration_2 <= 0.08100781589746475) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.37988099455833435) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.284114807844162) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - if (averageDuration_2 <= -0.504952996969223) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6233090758323669) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.2558213174343109) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.645479142665863) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2956107407808304) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.09400257840752602) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.21152733266353607) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3334933966398239) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236781001091003) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 1.5776891708374023) { - if (numDurations_2 <= 0.43938523530960083) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5537951290607452) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.24432819336652756) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.28796590864658356) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.009289418580010533) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.563823789358139) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= -1.837222695350647) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.850100576877594) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541325807571) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.050962820649147034) { - if (numDurations_2 <= 3.2851450443267822) { - if (maxDuration_2 <= -0.00455429358407855) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.07682698452845216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.3760383874177933) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.24339378625154495) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= 0.1603493019938469) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2625754326581955) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.26987220346927643) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2853277772665024) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.21207299828529358) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.2241146564483643) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9464623630046844) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.22158926725387573) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.26862944662570953) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6546749770641327) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508275985718) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.9040390849113464) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.012018587440252304) { - if (averageDuration_2 <= -0.018513771705329418) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345905259251595) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.8143337965011597) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6754757165908813) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 0.7037045955657959) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.6321735382080078) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.40611760318279266) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.29171763360500336) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.11044968664646149) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.026467518880963326) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3669063150882721) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8041815161705017) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6945921778678894) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5838739275932312) { - if (maxDuration_2 <= 1.2148786187171936) { - if (numDurations_2 <= 1.5776891708374023) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066322088241577) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.24865853786468506) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7213721573352814) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.075559675693512) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= 0.3087778091430664) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8727467060089111) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4397130012512207) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.49243196845054626) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2545369863510132) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7695936262607574) { - if (maxDuration_2 <= 1.6226548552513123) { - if (averageDuration_2 <= -0.1842714548110962) { - if (maxDuration_2 <= 0.7798659205436707) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4672095626592636) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8003976345062256) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.7111433446407318) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4093919396400452) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7568724155426025) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= 0.1766730546951294) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.4765240550041199) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5576425194740295) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.23622824251651764) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 0.27154649794101715) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089094400406) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.045294132083654404) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7346155643463135) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.20376486331224442) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1958169341087341) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= -1.837222695350647) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.564697802066803) { - if (maxDuration_2 <= 0.22109846025705338) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.644312173128128) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6941463351249695) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.128469467163086) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2944450378417969) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.32033464312553406) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.014264244586229324) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.06316339969635) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.204942524433136) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.0774097442626953) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3627431094646454) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.2289574146270752) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.2364568710327148) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 0.8165784180164337) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.05177287291735411) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.5612579137086868) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3983716368675232) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.204942524433136) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484406530857086) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.35129597783088684) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3138785809278488) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404551506042) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.5193292051553726) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3651854991912842) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4942823797464371) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.9446317553520203) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2029850482940674) { - if (averageDuration_2 <= 0.7512552440166473) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.9766682684421539) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5962963998317719) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.7139012813568115) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6604832112789154) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.861770749092102) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8404964208602905) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.603541374206543) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.720045804977417) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.13044001534581184) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0967368483543396) { - if (maxDuration_2 <= 0.21898876130580902) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.134287178516388) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.12923303991556168) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3709937930107117) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.134287178516388) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835330963135) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.11133947968482971) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1395991444587708) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3102819621562958) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1402398720383644) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.9790320694446564) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (averageDuration_2 <= 0.647126317024231) { - if (averageDuration_2 <= 0.6223336756229401) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.189287006855011) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (maxDuration_2 <= 1.2641422748565674) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5146777927875519) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5722512304782867) { - if (maxDuration_2 <= 0.5580757856369019) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (maxDuration_2 <= 0.2395162582397461) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (maxDuration_2 <= 0.10211512818932533) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.59490168094635) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.06567713618278503) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (maxDuration_2 <= -0.00026384844386484474) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.11663258820772171) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.645479142665863) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.347576379776001) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= -0.12976674735546112) { - if (averageDuration_2 <= 0.4105546176433563) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5184089094400406) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507169485092) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.23255515098571777) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8481956124305725) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5703380405902863) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.24216292798519135) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066322088241577) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09554325044155121) { - if (maxDuration_2 <= 0.591940313577652) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= 0.4334671050310135) { - if (averageDuration_2 <= -0.05438607931137085) { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1981149911880493) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7312967777252197) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9557093977928162) { - if (averageDuration_2 <= -0.4332282394170761) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= -0.6989187151193619) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6542955935001373) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.19144360721111298) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.26461537182331085) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.2405899614095688) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2006407976150513) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.808729112148285) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.47328467667102814) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.326260566711426) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.09997040778398514) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.15367309004068375) { - if (averageDuration_2 <= -0.2456832230091095) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.14436258375644684) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541474819183) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.44567954540252686) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6165053844451904) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5174239277839661) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.233595609664917) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9104954898357391) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.46606843173503876) { - if (maxDuration_2 <= 0.006105792126618326) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4948379844427109) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - if (averageDuration_2 <= -0.060847021639347076) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.32389242947101593) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { - if (maxDuration_2 <= 0.1284346655011177) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.3373135179281235) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { - if (maxDuration_2 <= 0.028464345261454582) { - if (averageDuration_2 <= -0.20067235827445984) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.7367621660232544) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5455034971237183) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7538002729415894) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.42289362847805023) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.19059136509895325) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.45020928978919983) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2814564108848572) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.22981609404087067) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.08745843172073364) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.23933130502700806) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.35513000190258026) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.34444981813430786) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404849529266) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= 0.340190589427948) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.08795669302344322) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.8602667450904846) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (averageDuration_2 <= -0.23837218433618546) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9757799506187439) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1762663498520851) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 0.25750577449798584) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9427586495876312) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.18798433244228363) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.03266109898686409) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.1954955905675888) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.2003083229064941) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7061541080474854) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1694013774394989) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.15917666256427765) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.19570736587047577) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.6332000494003296) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8922097086906433) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - if (averageDuration_2 <= -0.4548991918563843) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3077685609459877) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0775180496275425) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.7946025133132935) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.200829565525055) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.325911283493042) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.264043152332306) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.4923414885997772) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740303099155426) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - if (averageDuration_2 <= -0.1628672480583191) { - if (maxDuration_2 <= 0.238971546292305) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22695346921682358) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.39184698462486267) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.011927980929613113) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { - if (maxDuration_2 <= 0.16849935799837112) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.19052860885858536) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - if (averageDuration_2 <= -0.20970242470502853) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0714032649993896) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.3650086671113968) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.08676952123641968) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.4137696176767349) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.21426266431808472) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.7367621660232544) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.1754255294799805) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.19641231000423431) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (averageDuration_2 <= 0.3357199877500534) { - if (maxDuration_2 <= 0.19469265639781952) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.5414674282073975) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.6982106566429138) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= 0.3010910302400589) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.36013662815093994) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.46160899102687836) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5088231265544891) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5078662931919098) { - if (averageDuration_2 <= 0.07704402506351471) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.00955027062445879) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11448447220027447) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.960754632949829) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.7221550345420837) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3103668689727783) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.2663294672966003) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.2057140469551086) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.1070023775100708) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.662456214427948) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5572963654994965) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= 0.24020279943943024) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3551264554262161) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.011409632861614227) { - if (maxDuration_2 <= 0.015003126580268145) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.10219529643654823) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4689117670059204) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.4090394079685211) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.18726923316717148) { - if (maxDuration_2 <= 0.11821287497878075) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.760370969772339) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.31715817749500275) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.938111960887909) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.04032540135085583) { - if (maxDuration_2 <= 0.4042450040578842) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.040434835478663445) { - if (averageDuration_2 <= -0.04784642904996872) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1417597234249115) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - if (maxDuration_2 <= 0.1968277022242546) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9661673307418823) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5891313254833221) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 0.013557552359998226) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0462589859962463) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6213195323944092) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.0763629823923111) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 1.5776891708374023) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1315220594406128) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.12629256397485733) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5120928287506104) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.372219517827034) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740303099155426) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7030073404312134) { - if (averageDuration_2 <= -0.12176282703876495) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.10737277939915657) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5017814785242081) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.2471645325422287) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (maxDuration_2 <= 1.0187520384788513) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.03747232258319855) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.17631423473358154) { - if (averageDuration_2 <= 0.39042238891124725) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.4205806255340576) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { - if (maxDuration_2 <= 0.6244499981403351) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.41048693656921387) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9475547671318054) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.12649182975292206) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3103435635566711) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { - if (averageDuration_2 <= 0.26189276576042175) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3080918490886688) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.28542277216911316) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.35884347558021545) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.30719996988773346) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.36921536922454834) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.20676742494106293) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2022235244512558) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.30748067796230316) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.06601608544588089) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6021405160427094) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5903348922729492) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.2432587966322899) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.26420241594314575) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3126506507396698) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1915278360247612) { - if (averageDuration_2 <= 0.23476268351078033) { - if (numDurations_2 <= 2.7159931659698486) { - if (averageDuration_2 <= -0.14075449854135513) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.043676257133484) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= 0.5290503799915314) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.9290050268173218) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5331178903579712) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.9304614961147308) { - if (averageDuration_2 <= 0.523498922586441) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.02982225827872753) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3661118149757385) { - if (averageDuration_2 <= -0.2360268235206604) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.349144771695137) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.4765240550041199) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2877402901649475) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.4995386600494385) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.06261585839092731) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.4747196286916733) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.3828223645687103) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1477399542927742) { - if (averageDuration_2 <= 0.531990647315979) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7270525693893433) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9306365549564362) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.022392213344574) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.03219803236424923) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7134906649589539) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.483604371547699) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.12772595882415771) { - if (averageDuration_2 <= -0.30329519510269165) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= 0.6620207726955414) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (numDurations_2 <= -1.2680706679821014) { - if (averageDuration_2 <= 0.6567644476890564) { - if (averageDuration_2 <= 0.4407403916120529) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.9623591303825378) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0971235036849976) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4591042846441269) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6387370228767395) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.1783012747764587) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7606276273727417) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.2663294672966003) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7692232131958008) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5375382006168365) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.13610926270484924) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= 1.0951229333877563) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (maxDuration_2 <= 1.0110780596733093) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.047946153208613396) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.5647449493408203) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= -0.6989187151193619) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.5116665959358215) { - if (maxDuration_2 <= 0.5094125866889954) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.823574423789978) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6587873995304108) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7184686958789825) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= 0.15830105543136597) { - if (averageDuration_2 <= -0.25264767557382584) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.2296210527420044) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.134287178516388) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4334494471549988) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.5406128168106079) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.399016797542572) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.013062774669378996) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.12039435282349586) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.346752166748047) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.2223153710365295) { - if (maxDuration_2 <= 0.6079950332641602) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - if (averageDuration_2 <= -0.4831068068742752) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6850058436393738) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.625324845314026) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5377740263938904) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.696106195449829) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 0.10628174617886543) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.270564317703247) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.976557970046997) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6826225817203522) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.338785767555237) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.3886886835098267) { - if (averageDuration_2 <= 0.6465851366519928) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 0.9989573061466217) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.49198198318481445) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6604642868041992) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.608759045600891) { - if (averageDuration_2 <= 0.149479478597641) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.873420536518097) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.3776618391275406) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.3349531292915344) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4872465431690216) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8286791443824768) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.4670807719230652) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9893559217453003) { - if (maxDuration_2 <= 0.2875714749097824) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.5634623765945435) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2735583335161209) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2322942242026329) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.5640164613723755) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1599389910697937) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.26053740084171295) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.3393375277519226) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.037634821608662605) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4341423660516739) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= 1.008537232875824) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.300660490989685) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5481379926204681) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.74850994348526) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.22807607799768448) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404551506042) { - if (averageDuration_2 <= -0.44030220806598663) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.35109637677669525) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2442367970943451) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (maxDuration_2 <= 0.04911096580326557) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5336957275867462) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.31663385033607483) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= 0.9177788197994232) { - if (maxDuration_2 <= 0.9048139750957489) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101411759853363) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5393618047237396) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1476746797561646) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8255003392696381) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= 0.04987577348947525) { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.2542556524276733) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.34488406777381897) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5997462868690491) { - if (maxDuration_2 <= 0.1228933222591877) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1924630403518677) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= -0.02384578250348568) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.493928551673889) { - if (maxDuration_2 <= 0.3424929231405258) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485781908035278) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5536487102508545) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - if (maxDuration_2 <= 0.24306710064411163) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - if (averageDuration_2 <= -0.34951135516166687) { - if (averageDuration_2 <= -0.5102205872535706) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= 0.2355981022119522) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7935495674610138) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.07682698452845216) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= 0.19909172505140305) { - if (averageDuration_2 <= -0.5917091369628906) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.709421396255493) { - if (averageDuration_2 <= -0.3374997675418854) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7052638530731201) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.5206778347492218) { - if (maxDuration_2 <= 0.2138574719429016) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5572963654994965) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.963934600353241) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.8050788938999176) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8608003258705139) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.2542518377304077) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.7359728813171387) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0310637950897217) { - if (maxDuration_2 <= 0.6153853833675385) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.1602839156985283) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.593091070652008) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.148585021495819) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.0095096826553345) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.960754632949829) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0902730822563171) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - if (maxDuration_2 <= 0.0029070632881484926) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (averageDuration_2 <= -0.11169939115643501) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5737024247646332) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7684641182422638) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9963940382003784) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.2279265746474266) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.3634660094976425) { - if (averageDuration_2 <= -0.15652602910995483) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7951367497444153) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.648976445198059) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5488219261169434) { - if (maxDuration_2 <= 1.0876792669296265) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.1618149280548096) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606539070606) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8362123668193817) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.8949843645095825) { - if (averageDuration_2 <= 0.36479055881500244) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0398183465003967) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (numDurations_2 <= 0.43938523530960083) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186675310135) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248238757252693) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.31476010382175446) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.599594235420227) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= -0.6989187151193619) { - if (maxDuration_2 <= 0.22383133322000504) { - if (averageDuration_2 <= 0.2665567994117737) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1161888241767883) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.2662731409072876) { - if (averageDuration_2 <= 0.17798041552305222) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { - if (maxDuration_2 <= 0.5109928846359253) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8166762888431549) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5365391075611115) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.471769571304321) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.625324845314026) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8380617797374725) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7006752490997314) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306547224521637) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289728224277496) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.08066484704613686) { - if (maxDuration_2 <= 0.03190127480775118) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.13775229454040527) { - if (averageDuration_2 <= 0.16966138780117035) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8814636766910553) { - if (maxDuration_2 <= 0.4612787216901779) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7195698320865631) { - if (maxDuration_2 <= 0.33206577599048615) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1721528396010399) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.0371131300926208) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6631757915019989) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.609273076057434) { - if (averageDuration_2 <= -0.4051600247621536) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - if (averageDuration_2 <= -0.6397821605205536) { - if (maxDuration_2 <= 0.11055146530270576) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.3828223794698715) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5737563967704773) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7447831928730011) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367631524801254) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.1934889554977417) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.925930917263031) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.25455667078495026) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.055057622492313385) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.03730260394513607) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.29769961535930634) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.014404535293579) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.12158455327153206) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.6982106566429138) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.13235384225845337) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.12640100717544556) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9296188056468964) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.625324845314026) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0501359105110168) { - if (maxDuration_2 <= 0.20252370089292526) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.26100869476795197) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7554371058940887) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.33948375284671783) { - if (averageDuration_2 <= -0.5222404301166534) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.31374046206474304) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4923478662967682) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.6512565314769745) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.4140491485595703) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.841257691383362) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.02788958977907896) { - if (averageDuration_2 <= -0.42026522755622864) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (averageDuration_2 <= -0.3288869708776474) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.806822419166565) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.094433307647705) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.5304139256477356) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7382455170154572) { - if (maxDuration_2 <= 0.17132080346345901) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9592720866203308) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.4354717582464218) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.2848228812217712) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7406724989414215) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.18054499477148056) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.34444981813430786) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6591601371765137) { - if (maxDuration_2 <= 2.008854866027832) { - if (averageDuration_2 <= 0.03735444135963917) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.018952965736389) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 0.038451360538601875) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.4475434422492981) { - if (numDurations_2 <= 1.008537232875824) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.0976392030715942) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.601545661687851) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.014058990869671106) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.6184421181678772) { - if (maxDuration_2 <= 3.182745337486267) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 5.666366100311279) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.2170642614364624) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3856501877307892) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.1272987127304077) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - if (maxDuration_2 <= 3.485931158065796) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9473508894443512) { - if (averageDuration_2 <= 0.39343005418777466) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.14831599220633507) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.358581781387329) { - if (maxDuration_2 <= 2.7372950315475464) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.41800060868263245) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4634422063827515) { - if (maxDuration_2 <= 2.4467395544052124) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 1.578337848186493) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.5414674282073975) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.01674596732482314) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.18390513956546783) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.21660030633211136) { - if (maxDuration_2 <= 4.910945415496826) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (maxDuration_2 <= 3.815971255302429) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.5715272426605225) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= 4.981967210769653) { - if (averageDuration_2 <= 0.4226730018854141) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.45147131383419037) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.30288489162921906) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.352748155593872) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.9968165755271912) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.29440927505493164) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8468046188354492) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2647775262594223) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.10614394396543503) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.0642496682703495) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2528754621744156) { - if (averageDuration_2 <= -0.017338799312710762) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.20099686086177826) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.38652369379997253) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.7221550345420837) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4294944703578949) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - if (maxDuration_2 <= 4.909792900085449) { - if (averageDuration_2 <= -0.198727548122406) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7820281088352203) { - if (averageDuration_2 <= -0.4681995064020157) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.26573875546455383) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.128469467163086) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.49579326808452606) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6164599061012268) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.035555776208639145) { - if (averageDuration_2 <= -0.09163215011358261) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5795921385288239) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0226173400878906) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.18484089523553848) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.02609582617878914) { - if (maxDuration_2 <= 1.2965781688690186) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9963939785957336) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2375742197036743) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.23903899639844894) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5708679258823395) { - if (averageDuration_2 <= 0.319341316819191) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.2951493263244629) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.029591893777251244) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6358306407928467) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.0258170664310455) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.8653557300567627) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9978135228157043) { - if (maxDuration_2 <= 3.0989508628845215) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6876242756843567) { - if (averageDuration_2 <= -0.02123983483761549) { - if (maxDuration_2 <= 1.330518901348114) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.11954734101891518) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.3495359569787979) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5400809645652771) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= 1.7244536876678467) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4429995268583298) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (averageDuration_2 <= -0.18221993744373322) { - if (averageDuration_2 <= -0.46643994748592377) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.9565199613571167) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.832880437374115) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4787856638431549) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 2.572287678718567) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3038039058446884) { - if (averageDuration_2 <= -0.06728924065828323) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.14966480433940887) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7842196524143219) { - if (maxDuration_2 <= 2.1740193367004395) { - if (numDurations_2 <= -0.12976674735546112) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6557387709617615) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 1.4388421773910522) { - if (maxDuration_2 <= 1.3678559064865112) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6130359321832657) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7291649281978607) { - if (averageDuration_2 <= -0.20401102304458618) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (maxDuration_2 <= 2.8405961990356445) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536155462265) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0211151242256165) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.10438440088182688) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= 2.3012441396713257) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7122454047203064) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0133654475212097) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7215404212474823) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8237243294715881) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4501678943634033) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.7930396795272827) { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (numDurations_2 <= 1.8622651100158691) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7043106555938721) { - if (maxDuration_2 <= 1.468436598777771) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.42650002241134644) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.014460311038419604) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8830764293670654) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.7972663044929504) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1519950106739998) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - if (maxDuration_2 <= 2.360835909843445) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.23324685543775558) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1051284670829773) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.41893546283245087) { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.030721173621714115) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 2.0507278442382812) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.373752474784851) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.4203786849975586) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3946537375450134) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1699317991733551) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.27762463688850403) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.36891959607601166) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5319692194461823) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 2.6360456943511963) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.7139012813568115) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8777981996536255) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9890867471694946) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.160470485687256) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3231569826602936) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.42911046743392944) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.242385745048523) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= 1.008537232875824) { - if (maxDuration_2 <= 0.4649232178926468) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2641295790672302) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.760370969772339) { - if (maxDuration_2 <= 0.06713099218904972) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.8825266361236572) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08409106731414795) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2070707008242607) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5974637269973755) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4602627158164978) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4690933972597122) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.4282166212797165) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.13024095445871353) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.055903466418385506) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.8538601398468018) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4064010977745056) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - if (maxDuration_2 <= 0.2545679360628128) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (maxDuration_2 <= 0.43389272689819336) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15984783321619034) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6669895648956299) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6042918562889099) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7460454404354095) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4235254526138306) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.10923456400632858) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.925930917263031) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.7091822624206543) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - if (maxDuration_2 <= 0.34415431320667267) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3823658227920532) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7036847472190857) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6956122517585754) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5180899649858475) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7430383861064911) { - if (maxDuration_2 <= 0.23097094893455505) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 0.13901548832654953) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5139202773571014) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.692499577999115) { - if (averageDuration_2 <= 0.39394593238830566) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4623380899429321) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.16271371394395828) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.3266964703798294) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 0.19511732459068298) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617429971694946) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.7617704272270203) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.3666815757751465) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (maxDuration_2 <= 0.22189629822969437) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.45281267166137695) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6427231132984161) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 0.16722805052995682) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (averageDuration_2 <= 0.759729415178299) { - if (averageDuration_2 <= 0.7402538657188416) { - if (averageDuration_2 <= 0.4737645387649536) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4932494163513184) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.15044831112027168) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (maxDuration_2 <= 0.3349025100469589) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4329689145088196) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= 0.8788341879844666) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.24553610384464264) { - if (averageDuration_2 <= 0.20318251103162766) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.3737525939941406) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7334689199924469) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (numDurations_2 <= -1.837222695350647) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.2123268842697144) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4546836018562317) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= 0.270169273018837) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.33310049772262573) { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7439887523651123) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.36807067692279816) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.14624148607254028) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6198905408382416) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.8027482628822327) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.6672534942626953) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.16123215854167938) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= 0.3516284227371216) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.07683756202459335) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.020525816828012466) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4947177469730377) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { - if (averageDuration_2 <= 0.38153761625289917) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8454057574272156) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.232944056391716) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5912105441093445) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.9434725046157837) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.498771011829376) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.3255631923675537) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.8771063089370728) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2077157497406006) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6941463053226471) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 0.15843714028596878) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.582572817802429) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 0.31164078414440155) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8814854323863983) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3357419818639755) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.060017228126526) { - if (cpuCoreIdleTimesPercentage_7_2 <= -4.302473545074463) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4602354168891907) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.4995386600494385) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1596840620040894) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= 0.17295461893081665) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2288528084754944) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 0.2918156832456589) { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.2990409135818481) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7354987263679504) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.181956171989441) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.688767433166504) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8035789132118225) { - if (averageDuration_2 <= 0.7162552773952484) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.3800418376922607) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.7930396795272827) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.4652613401412964) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= 0.1468046009540558) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2432098388671875) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8599216341972351) { - if (maxDuration_2 <= 0.11646275408565998) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.12426672503352165) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.0026832818984985) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4169272929430008) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.4421444535255432) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.17399810999631882) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4627494364976883) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.3346111476421356) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.9587630033493042) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4607649445533752) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.960754632949829) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3681035339832306) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2705179452896118) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3691399693489075) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (maxDuration_2 <= 0.39605432748794556) { - if (averageDuration_2 <= 0.3863515257835388) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3358411639928818) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.0976392030715942) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4419679343700409) { - if (maxDuration_2 <= 0.41109326481819153) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.16544219851493835) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (maxDuration_2 <= 0.02103857323527336) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.33809444308280945) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.484076499938965) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.006260633468628) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6941463351249695) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.28045739233493805) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.9353829622268677) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= 0.03758057951927185) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040612459183) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= 0.3192882388830185) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { - if (averageDuration_2 <= 0.286331444978714) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.768178939819336) { - if (maxDuration_2 <= 0.2374088540673256) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.0572593212127686) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 0.01505080284550786) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.1641088724136353) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.47781626880168915) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.352748155593872) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.0975580215454102) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4413849115371704) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3357419818639755) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3360027074813843) { - if (averageDuration_2 <= -0.06993165984749794) { - if (maxDuration_2 <= 0.30900058150291443) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.21650774776935577) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= 0.7480875551700592) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9142167568206787) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.0976390838623047) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.10821932554245) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4607385396957397) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4592827558517456) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.3494577407836914) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 0.3182414323091507) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numMissedDeadlines_2 <= 0.4979674816131592) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7108749151229858) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.37633462250232697) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6926724910736084) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.25773176550865173) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1161888539791107) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.5930910110473633) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= 0.41057874262332916) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.128469467163086) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612544775009155) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.9565199315547943) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.3846242427825928) { - if (averageDuration_2 <= 0.30631570518016815) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5662427842617035) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5678754448890686) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3727903962135315) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (maxDuration_2 <= 1.7909623980522156) { - if (maxDuration_2 <= 0.7245444655418396) { - if (averageDuration_2 <= 0.5259277820587158) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3064705431461334) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (averageDuration_2 <= -0.03269064240157604) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.1982994675636292) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.373752474784851) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4337494373321533) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.16236130148172379) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 0.43938523530960083) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.1122801303863525) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7010758519172668) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.3175666481256485) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - if (averageDuration_2 <= -0.2930971831083298) { - if (maxDuration_2 <= 0.4932436943054199) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4423782229423523) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4605891108512878) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.41546398401260376) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= 0.33926577866077423) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.702899217605591) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5665489435195923) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.5477566719055176) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.160470485687256) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.151027202606201) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0682660341262817) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8089553713798523) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= 0.029220184311270714) { - if (averageDuration_2 <= -0.35949476063251495) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3612300753593445) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4429798126220703) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.9290050268173218) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.40162627398967743) { - if (averageDuration_2 <= -0.33695654571056366) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.080251395702362) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.23657985031604767) { - if (maxDuration_2 <= 0.6224770247936249) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3957411050796509) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.26358339190483093) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.48647381365299225) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.4843236207962036) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= 0.2447957992553711) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= 0.03269314020872116) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17675691843032837) { - if (numDurations_2 <= -0.12976674735546112) { - if (maxDuration_2 <= 0.5635538399219513) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.8274345993995667) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.22494500875473022) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 0.016571398824453354) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2710963487625122) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.016184553503990173) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.37983131408691406) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (maxDuration_2 <= 0.6883193552494049) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - if (averageDuration_2 <= 0.08237481862306595) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.029591891914606094) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4626663327217102) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.2969357818365097) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.38254110515117645) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485684156417847) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.5420159101486206) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.5542387068271637) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4169272780418396) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2898950576782227) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9593591094017029) { - if (maxDuration_2 <= 0.5500800609588623) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1424911767244339) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1763165071606636) { - if (numMissedDeadlines_2 <= 4.563007950782776) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.886878728866577) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.462079107761383) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461315095424652) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4606261849403381) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.9968165159225464) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3103435635566711) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.14925425499677658) { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.5853307247161865) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8703529834747314) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.1735504865646362) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3718595430254936) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.6982106566429138) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.25132977217435837) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.23871616274118423) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.4774004966020584) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1239492893218994) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.26533639430999756) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5082795917987823) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.14615275710821152) { - if (maxDuration_2 <= 1.162107527256012) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485603094100952) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4625609964132309) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.9883725345134735) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= 0.1443113312125206) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1161888539791107) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.65778249502182) { - if (maxDuration_2 <= 0.981174498796463) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -3.0809937715530396) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5417258441448212) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.7944985032081604) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4534569382667542) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.0048857927322388) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.15142414346337318) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117392778396606) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.8389183282852173) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.6557488441467285) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9380844235420227) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615720510482788) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404551506042) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1738549917936325) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.11063998937606812) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7212187647819519) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.142114996910095) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.7539262473583221) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4968719333410263) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17573968321084976) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15608662366867065) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5901694595813751) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6401868760585785) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14401210844516754) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 1.224535882472992) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 1.5809946656227112) { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4256374388933182) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6192947626113892) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17034465819597244) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.8949843645095825) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (averageDuration_2 <= 0.08805647119879723) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5417258441448212) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= 1.5916523337364197) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.18798432499170303) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7072669267654419) { - if (averageDuration_2 <= 0.03242693655192852) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.7091822624206543) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.17228609323501587) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { - if (averageDuration_2 <= 0.5928299427032471) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.338785767555237) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.516908645629883) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.9542267918586731) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040612459183) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.5482349395751953) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4636659026145935) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.97825688123703) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.3255345225334167) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4622002840042114) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.6927345991134644) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - if (maxDuration_2 <= 0.8587973415851593) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.316119909286499) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.9915950894355774) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 0.51321941614151) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.584539920091629) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.028396189212799) { - if (maxDuration_2 <= 3.2875101566314697) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 3.3500877618789673) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.40310265123844147) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 3.0232993364334106) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.092849254608154) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 2.3364663124084473) { - if (averageDuration_2 <= 0.3411664217710495) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0555312037467957) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.2480701804161072) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.648976445198059) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.8631930947303772) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.5494454503059387) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.1070024073123932) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.4362072944641113) { - if (maxDuration_2 <= 4.432061433792114) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.2123268842697144) { - if (averageDuration_2 <= 0.7457267045974731) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8908034265041351) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615456461906433) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= 0.4695110470056534) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.24652601033449173) { - if (maxDuration_2 <= 0.5770659148693085) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (maxDuration_2 <= 0.36416269838809967) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (averageDuration_2 <= -0.3869647681713104) { - if (maxDuration_2 <= 0.228671133518219) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.17070672661066055) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8386341035366058) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.8780616521835327) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14625396579504013) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.30469673871994) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.853439599275589) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9738000631332397) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3480595350265503) { - if (maxDuration_2 <= 0.0019319088896736503) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.304485559463501) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3251873254776) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.960754632949829) { - if (maxDuration_2 <= 0.16205382347106934) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17518071085214615) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5687283873558044) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6245782375335693) { - if (averageDuration_2 <= -0.46553266048431396) { - if (averageDuration_2 <= -0.48726001381874084) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14163348078727722) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1051284670829773) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.13689523935318) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - if (averageDuration_2 <= -0.42365221679210663) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.11029172502458096) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4622228145599365) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.218447744846344) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.40358296036720276) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8963220119476318) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { - if (numDurations_2 <= 7.269208669662476) { - if (maxDuration_2 <= 0.2532256096601486) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.3594858050346375) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1489261984825134) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.778379797935486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.30817437171936035) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5458608269691467) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2128134369850159) { - if (averageDuration_2 <= -0.41881464421749115) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.8452296257019043) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 4.4234490394592285) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.4340621829032898) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.49446921050548553) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8363194167613983) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23798730969429016) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { - if (averageDuration_2 <= -0.47706229984760284) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.29736481606960297) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597728431224823) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.04257108271121979) { - if (numDurations_2 <= 1.5776891708374023) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21516287326812744) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.030815708450973034) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.7312291860580444) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617557525634766) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.879536509513855) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1079137846827507) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.41479460895061493) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= 0.28744223713874817) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (averageDuration_2 <= -0.263033851981163) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - if (maxDuration_2 <= 0.08310211077332497) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.7504843473434448) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.8025574684143066) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.1641088724136353) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5342928767204285) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6583120822906494) { - if (maxDuration_2 <= 0.23145464807748795) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numMissedDeadlines_2 <= 0.4979674816131592) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.45153340697288513) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.9363716542720795) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.6982106566429138) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.883341372013092) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619413614273071) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7456344366073608) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461660921573639) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.34969064593315125) { - if (averageDuration_2 <= -0.3219815343618393) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3512469679117203) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.22002233564853668) { - if (maxDuration_2 <= 0.22938043624162674) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (averageDuration_2 <= -0.3853195756673813) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.462589144706726) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2266959547996521) { - if (numDurations_2 <= 1.5776891708374023) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.9381119310855865) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 0.13904931396245956) { - if (averageDuration_2 <= -0.3737427294254303) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619316458702087) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.04197080433368683) { - if (numMissedDeadlines_2 <= 0.4979674816131592) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9475547671318054) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461845576763153) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.205658197402954) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.48337236046791077) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.05921563133597374) { - if (averageDuration_2 <= -0.26436731219291687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.215610109269619) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - if (averageDuration_2 <= -0.4224219024181366) { - if (averageDuration_2 <= -0.6485199630260468) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.4340621829032898) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.37765470147132874) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4611558318138123) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2302071452140808) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748422235250473) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.911641538143158) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6058032512664795) { - if (averageDuration_2 <= -0.41182178258895874) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.4125157594680786) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= -0.00799873098731041) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3434019237756729) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6548566222190857) { - if (maxDuration_2 <= 0.21885952353477478) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619531035423279) { - if (averageDuration_2 <= -0.6227836608886719) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (averageDuration_2 <= -0.4066706448793411) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3224920630455017) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1393211483955383) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319177746773) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.06895006448030472) { - if (averageDuration_2 <= -0.299502357840538) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0026367604732513) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.20263753086328506) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.4995386600494385) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.23457122594118118) { - if (maxDuration_2 <= 0.11994269490242004) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0551071763038635) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2927219867706299) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.444460391998291) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.5297087132930756) { - if (numDurations_2 <= 4.992600917816162) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5771615207195282) { - if (numDurations_2 <= 4.4234490394592285) { - if (averageDuration_2 <= -0.7463608682155609) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.8437918424606323) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4599745273590088) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.876897096633911) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7768742442131042) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111890792847) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.1186872720718384) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.289841890335083) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.688767433166504) { - if (numDurations_2 <= 1.5776891708374023) { - if (averageDuration_2 <= -0.47417721152305603) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 5.8463287353515625) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541474819183) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.25230975449085236) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (maxDuration_2 <= 0.3879142701625824) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.3032449036836624) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.5304139256477356) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3699759989976883) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.594074934720993) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486122846603394) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3019879460334778) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.21843662858009338) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.0446120500564575) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7303748428821564) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618543982505798) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.218447744846344) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.7284773588180542) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.24020425975322723) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.4400789737701416) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5991550087928772) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - if (averageDuration_2 <= -0.5701561570167542) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.676054000854492) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7746920883655548) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - if (averageDuration_2 <= -0.26591894030570984) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27514003217220306) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.34710994362831116) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.07932132855057716) { - if (averageDuration_2 <= -0.4028385579586029) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8002727627754211) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.06242578476667404) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.34450162947177887) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.23222923278808594) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0875993371009827) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.21737030148506165) { - if (averageDuration_2 <= -0.6032171845436096) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4630483984947205) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2447747588157654) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619081616401672) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7213721573352814) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.134287178516388) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4148825109004974) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.8631931245326996) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.034897420555353165) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3119745999574661) { - if (averageDuration_2 <= -0.5034425109624863) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6393420994281769) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (averageDuration_2 <= -0.29016993939876556) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485481202602386) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.44852393865585327) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.3049110323190689) { - if (averageDuration_2 <= -0.4972231090068817) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7089749872684479) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.3004702627658844) { - if (maxDuration_2 <= 0.010540442541241646) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1042715907096863) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186675310135) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.2469632625579834) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.542070746421814) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.15265657007694244) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9246130585670471) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.19496869295835495) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9736073017120361) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2479664087295532) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.745672583580017) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3851780444383621) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4534289836883545) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (averageDuration_2 <= -0.47637568414211273) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4634822010993958) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1179419495165348) { - if (maxDuration_2 <= 0.11849404126405716) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.1677878350019455) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3039478361606598) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (averageDuration_2 <= -0.4132165163755417) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.2460106015205383) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1760829091072083) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -3.188812732696533) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.010598020628094673) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.42520859837532043) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.25722745060920715) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1195555329322815) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4630027413368225) { - if (averageDuration_2 <= -0.5339729487895966) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.3525003492832184) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.5381681025028229) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7875808775424957) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4106923937797546) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5146772265434265) { - if (averageDuration_2 <= -0.34361034631729126) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.10625581443309784) { - if (averageDuration_2 <= -0.263743057847023) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07055109366774559) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.4869600981473923) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2184163331985474) { - if (numMissedDeadlines_2 <= 0.4979674816131592) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.005229495698586106) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4642882943153381) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5391302704811096) { - if (averageDuration_2 <= -0.3917224407196045) { - if (numDurations_2 <= 4.4234490394592285) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.23001007735729218) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2189591526985168) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4085732251405716) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4037279486656189) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.6928452253341675) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.8274345993995667) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - if (numDurations_2 <= 10.11496877670288) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.6321735382080078) { - if (maxDuration_2 <= 1.807799756526947) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3220030665397644) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8636736571788788) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.0371131300926208) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.6322885453701019) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4532228708267212) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617606401443481) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3241117596626282) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.8874699175357819) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.12880414724349976) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.7946025133132935) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.79072505235672) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.6672534942626953) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.548783004283905) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.45751993358135223) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (averageDuration_2 <= -0.40787628293037415) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.310221254825592) { - if (averageDuration_2 <= -0.5799572169780731) { - if (averageDuration_2 <= -0.7536517083644867) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.250082850456238) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616140127182007) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0625119805335999) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.63319993019104) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 4.6285271644592285) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.12016559392213821) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6850249469280243) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.0519715547561646) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.3262604475021362) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.1885876655578613) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.278771698474884) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.181956171989441) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= 2.137601852416992) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.43279071152210236) { - if (averageDuration_2 <= -0.028030233457684517) { - if (maxDuration_2 <= 0.22051330655813217) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.13677772134542465) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (maxDuration_2 <= 0.06054849363863468) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618651866912842) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.101522386074066) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5141507685184479) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.03827717341482639) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9475547671318054) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= 0.11253714188933372) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.345133662223816) { - if (maxDuration_2 <= 0.02429315261542797) { - if (averageDuration_2 <= -0.18166856467723846) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616326093673706) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404551506042) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.028837166726589203) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2689694166183472) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.25132977217435837) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4130169451236725) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.03822941519320011) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.9162233471870422) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2957223802804947) { - if (averageDuration_2 <= -0.05811733193695545) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748584657907486) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539397239685) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - if (averageDuration_2 <= -0.08933059871196747) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619433283805847) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.05304388329386711) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618377685546875) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.39444170892238617) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486106753349304) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.14397023618221283) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07005864009261131) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4120877385139465) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05572330951690674) { - if (maxDuration_2 <= -0.008705480489879847) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (averageDuration_2 <= -0.06050151586532593) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2312130704522133) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7907251119613647) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.46427084505558014) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= -0.005476200953125954) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6721392869949341) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.244322419166565) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.39513707160949707) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7222920358181) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485627233982086) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3732672780752182) { - if (averageDuration_2 <= -0.21237368136644363) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.03318239003419876) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.060193946585059166) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09827997162938118) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6793844103813171) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5991549491882324) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5198341310024261) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5126725137233734) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470267772675) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.893098771572113) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= 0.011039497796446085) { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.22537189722061157) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544506549835) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.290977358818054) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461627721786499) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4620019793510437) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.023615305311977863) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.4230196475982666) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.32493704557418823) { - if (averageDuration_2 <= -0.20794106274843216) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3813329190015793) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09174468740820885) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4461706876754761) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2674808204174042) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9414147138595581) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= -0.004197099944576621) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.9040391147136688) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (averageDuration_2 <= -0.10394452512264252) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2752511501312256) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.014869967941194773) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 1.2602974772453308) { - if (maxDuration_2 <= 0.39047472178936005) { - if (averageDuration_2 <= -0.15627028793096542) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1234126091003418) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.332435965538025) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.1530783399939537) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.6415618658065796) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= 0.27533090114593506) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 0.6195289492607117) { - if (averageDuration_2 <= -0.1860927864909172) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.59490168094635) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.23781165480613708) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= 1.0661715865135193) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.32573795318603516) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485733032226562) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (maxDuration_2 <= 1.6149300932884216) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - if (maxDuration_2 <= 0.24180826544761658) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1221141628921032) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (maxDuration_2 <= 0.8835214972496033) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2267187014222145) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.07615719363093376) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3563624396920204) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.19189206510782242) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618417024612427) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 1.2135262489318848) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5662542283535004) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2614276707172394) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5740767419338226) { - if (maxDuration_2 <= 0.4386211633682251) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 1.5776891708374023) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.9475353062152863) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.08678947389125824) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.5304139256477356) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.21696310490369797) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.05083497241139412) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4240179061889648) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.149984896183014) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.3218844532966614) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.8750420808792114) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3913271725177765) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (maxDuration_2 <= 0.8056817650794983) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5653949677944183) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.13629667088389397) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8261885643005371) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.13044001534581184) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= 0.03618403896689415) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.03773343376815319) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3350065350532532) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.6288281679153442) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6978297829627991) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617488980293274) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.003839071374386549) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5647778511047363) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4518350660800934) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13679742068052292) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.7091822624206543) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5579688251018524) { - if (maxDuration_2 <= 0.4793064296245575) { - if (maxDuration_2 <= 0.21935341507196426) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (maxDuration_2 <= 0.09651780873537064) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.075559675693512) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8261885643005371) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.16657786816358566) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.3569984436035156) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20548036694526672) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (averageDuration_2 <= 0.2837657779455185) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (maxDuration_2 <= 0.3051028251647949) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.2951493263244629) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6929609775543213) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7484812438488007) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.05159341171383858) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.216363549232483) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.25098615884780884) { - if (maxDuration_2 <= 0.5385511517524719) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 0.2211945801973343) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - if (maxDuration_2 <= 0.15003105252981186) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5708175152540207) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3467200696468353) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2140112966299057) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 0.019909885246306658) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.896321952342987) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616326093673706) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615007042884827) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3408273756504059) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1858297921717167) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { - if (maxDuration_2 <= 0.11735428124666214) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.09393413737416267) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.42461895942688) { - if (averageDuration_2 <= 0.28194038569927216) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4113236218690872) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.50744891166687) { - if (maxDuration_2 <= 2.0298534631729126) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.8986510038375854) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (maxDuration_2 <= 0.3110293298959732) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17433183640241623) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.12534869089722633) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 1.4071301817893982) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.4374130219221115) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 1.6439599394798279) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.36609846353530884) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 1.229755938053131) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.20332161337137222) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470267772675) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.01626251172274351) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.7939351499080658) { - if (maxDuration_2 <= 0.296785444021225) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5151970982551575) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 1.2984625101089478) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.171896517276764) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.8539550304412842) { - if (maxDuration_2 <= 0.302086278796196) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3132547438144684) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.37052251398563385) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.434457004070282) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2898950576782227) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.10738615319132805) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.009272754658013582) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= 0.36195260286331177) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= 0.04055340774357319) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1189902424812317) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2632790207862854) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (averageDuration_2 <= -0.021665476262569427) { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964074045419693) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 0.2118617221713066) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.79072505235672) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { - if (averageDuration_2 <= -0.09590443223714828) { - if (maxDuration_2 <= 0.8319051861763) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3922600746154785) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.9529157876968384) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6351950466632843) { - if (averageDuration_2 <= 0.02109418995678425) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= 0.2223849818110466) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6608707904815674) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= 0.022449105978012085) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3319229334592819) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619804620742798) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.33948376029729843) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8262928128242493) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.15399984270334244) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= -0.006225912598893046) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.028940661810338497) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0653241276741028) { - if (averageDuration_2 <= -0.03282356634736061) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.39341557025909424) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.016038838773965836) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= 0.7523583173751831) { - if (averageDuration_2 <= -0.1822899580001831) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.5941142290830612) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0394643247127533) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.577582448720932) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4105652570724487) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2331566214561462) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4833749979734421) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.22427384555339813) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8847585320472717) { - if (maxDuration_2 <= 0.21497700363397598) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.128469467163086) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.5408204197883606) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.797663688659668) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0970470905303955) { - if (averageDuration_2 <= 0.15577057749032974) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.14785322546958923) { - if (maxDuration_2 <= 1.3022134900093079) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4093919396400452) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.039908528327942) { - if (maxDuration_2 <= -0.006436079973354936) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.25400546193122864) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5058493167161942) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.2870839834213257) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614118337631226) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9362238049507141) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7373296320438385) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.6146548986434937) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.645479142665863) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614332914352417) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= 0.2269914671778679) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9186708033084869) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5245692431926727) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.21237558871507645) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5169532597064972) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.0585829615592957) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225883811712265) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4988882541656494) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - if (averageDuration_2 <= 0.2515539079904556) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.622090995311737) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= 4.785886287689209) { - if (averageDuration_2 <= 0.26195596158504486) { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.405732154846191) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.4863998889923096) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7170225083827972) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2763279676437378) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.5675357580184937) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.952915906906128) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - if (numDurations_2 <= 2.7159931659698486) { - if (maxDuration_2 <= 2.5764869451522827) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.5609686970710754) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.876897096633911) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.013322114944458) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.17731168866157532) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 3.1995418071746826) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.8508365154266357) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1653001457452774) { - if (maxDuration_2 <= 2.6575735807418823) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= 3.0148682594299316) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.21122296154499054) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 3.1250656843185425) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612886905670166) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5825729370117188) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { - if (maxDuration_2 <= 2.41451358795166) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0989459902048111) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.9034896492958069) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.7973603010177612) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.11557363718748093) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.7930396795272827) { - if (maxDuration_2 <= 3.146760582923889) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.952915906906128) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.817373812198639) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.1618149280548096) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4621612429618835) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.688767433166504) { - if (averageDuration_2 <= 0.3800201117992401) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= 7.635167121887207) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7601674497127533) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= 5.044552564620972) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.5414674282073975) { - if (numDurations_2 <= -1.2680706679821014) { - if (maxDuration_2 <= 0.6783531904220581) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.05709555000066757) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1290577054023743) { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3796064853668213) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.1678913533687592) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2673759460449219) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3187861442565918) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.6550031900405884) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.876897096633911) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.5675357580184937) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 4.527082920074463) { - if (averageDuration_2 <= 2.020587921142578) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (averageDuration_2 <= 2.019300699234009) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.127554178237915) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4610717296600342) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.1434627771377563) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.8408887684345245) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 1.8670645356178284) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.137565553188324) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9738001227378845) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.350590229034424) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5320121943950653) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= -1.837222695350647) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3421038389205933) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.7504844069480896) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177308797836304) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 1.8014256954193115) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.5566930770874023) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5027788877487183) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.1475950479507446) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.9434726238250732) { - if (maxDuration_2 <= 1.526749312877655) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.7574002742767334) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 0.439385250210762) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2860610783100128) { - if (numDurations_2 <= 0.43938523530960083) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.12626661732792854) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.43006178736686707) { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.027185082435608) { - if (numMissedDeadlines_2 <= 6.5955281257629395) { - if (maxDuration_2 <= 1.2213954329490662) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuCoreIdleTimesPercentage_7_2 <= -4.8056182861328125) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.622730255126953) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.360052227973938) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5203419327735901) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - if (maxDuration_2 <= 4.237208604812622) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.0015177130699158) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= 1.5044794082641602) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0916837751865387) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1346113122999668) { - if (maxDuration_2 <= 0.5957824885845184) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.30056197941303253) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1897109746932983) { - if (maxDuration_2 <= 3.1951706409454346) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.134947121143341) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.9034896492958069) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.1537500619888306) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { - if (maxDuration_2 <= 1.3252560496330261) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9406739771366119) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.749491214752197) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.743839293718338) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.8154819011688232) { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.35550594329834) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461492896080017) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (averageDuration_2 <= 2.291628837585449) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.013322114944458) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.9915950894355774) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0192918479442596) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 1.7040885090827942) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.7944985032081604) { - if (maxDuration_2 <= 0.6059436202049255) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6375060975551605) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2587464302778244) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.8907558917999268) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4223690927028656) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.663274109363556) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.39485372602939606) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 1.6104344129562378) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.887678474187851) { - if (maxDuration_2 <= 1.0535055994987488) { - if (numDurations_2 <= -1.837222695350647) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0022448897361755) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.34496691823005676) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7147404551506042) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.1641088724136353) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3447071462869644) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5491238534450531) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.15357730910182) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.0244272351264954) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.0371131300926208) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.25677254796028137) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5541929602622986) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48101936280727386) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613492488861084) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.00575818947982043) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.18140528351068497) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.9961256682872772) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3884168863296509) { - if (averageDuration_2 <= 1.4893895983695984) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.01875431463122368) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8873403668403625) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.0572593212127686) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.0946863479912281) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.13689523935318) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.13951494544744492) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.32151108980178833) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.1618149280548096) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.31480924785137177) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.16625051945447922) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7504318058490753) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.46158766746521) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6149652898311615) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.355647936463356) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.38558030128479) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.019662188831716776) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.011540561397850979) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.2490766644477844) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22202018648386002) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.0642496682703495) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0531170964241028) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9891899228096008) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.39978136122226715) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5383607149124146) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 1.539103388786316) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3138265907764435) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.5802874863147736) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2688552141189575) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319651782512665) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13596490770578384) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.025206602178514004) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20746057480573654) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.7558080554008484) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.729569673538208) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.4643928408622742) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9349343776702881) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.27657751739025116) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.06669353321194649) { - if (maxDuration_2 <= 1.2695014476776123) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1706795170903206) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4534569382667542) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 3.3745003938674927) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.6550031900405884) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.0145689249038696) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= 1.100279450416565) { - if (averageDuration_2 <= 1.8760048747062683) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= 1.2375778555870056) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.049462681636214256) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4586123377084732) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (numDurations_2 <= 0.43938523530960083) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (averageDuration_2 <= 2.1512858867645264) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7137278616428375) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5116468667984009) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.09014344029128551) { - if (maxDuration_2 <= 2.8213220834732056) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= 2.424679160118103) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8599216341972351) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.721377968788147) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6604832112789154) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6153981983661652) { - if (averageDuration_2 <= 2.0978039503097534) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4621641635894775) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4601367115974426) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4623468518257141) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.662456214427948) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6282088756561279) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.61161208152771) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.319189190864563) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 3.0371495485305786) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.23538777232170105) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 2.887550115585327) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= 2.359539747238159) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7482353746891022) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.29653431475162506) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3103435635566711) { - if (maxDuration_2 <= 1.2388759851455688) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5276185572147369) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5249494016170502) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 1.6485667824745178) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6514894366264343) { - if (maxDuration_2 <= 3.338495373725891) { - if (numDurations_2 <= -1.837222695350647) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3725270926952362) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239523053169) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5749098658561707) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5654532313346863) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07367156073451042) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.1885876655578613) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.9265406727790833) { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.2469632625579834) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.27204692363739) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.399016797542572) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05094969645142555) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3293897807598114) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4892883002758026) { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 5.020978689193726) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3983716368675232) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 1.8683618903160095) { - if (maxDuration_2 <= 1.8023314476013184) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4861375093460083) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.8759267926216125) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3822421282529831) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.261569023132324) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= 6.416047811508179) { - if (averageDuration_2 <= 1.316986083984375) { - if (averageDuration_2 <= 1.2343434691429138) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4416620135307312) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2840093523263931) { - if (numDurations_2 <= -1.837222695350647) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5661364197731018) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3543576002120972) { - if (maxDuration_2 <= 1.6516566276550293) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7853520214557648) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0722964107990265) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.016276582384307403) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4981125742197037) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.234639286994934) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.5941141843795776) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.49310925602912903) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.162411332130432) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.2911977767944336) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.9623591303825378) { - if (averageDuration_2 <= 1.310598075389862) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.997084766626358) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.38558030128479) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6891340613365173) { - if (maxDuration_2 <= 0.7302684783935547) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.508066862821579) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.03231922537088394) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.7287690937519073) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7941327691078186) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1893460676074028) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22730766981840134) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.9108937978744507) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613355994224548) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6790977120399475) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (maxDuration_2 <= 0.9613054990768433) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.5499634146690369) { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.0268927812576294) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6029710918664932) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.15292972326278687) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0022448897361755) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.4317436218261719) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= -0.12976674735546112) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4626829624176025) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (maxDuration_2 <= 2.110324501991272) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.6300016343593597) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08121922239661217) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08242103457450867) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.26995179057121277) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.7139012813568115) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.23185841739177704) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.802748203277588) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.938111960887909) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.724402904510498) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291577041149139) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4759628623723984) { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.5129289031028748) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1400446891784668) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5579615533351898) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3244428336620331) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7074764519929886) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4534569382667542) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5714039504528046) { - if (averageDuration_2 <= 2.1093735694885254) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - if (maxDuration_2 <= 6.129816055297852) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3212643787264824) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 6.195605754852295) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.016184553503990173) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615378379821777) { - if (maxDuration_2 <= 6.9213128089904785) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9760755896568298) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= 7.559720993041992) { - if (averageDuration_2 <= 3.7737587690353394) { - if (averageDuration_2 <= 3.709157705307007) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.34422287344932556) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= 0.9285858571529388) { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3021332025527954) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7243996858596802) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (maxDuration_2 <= 0.29267486929893494) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291517734527588) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 0.378357857465744) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - if (maxDuration_2 <= 0.1460927575826645) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.34018470346927643) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.7305975258350372) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.835627019405365) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7299784421920776) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= 0.6305077075958252) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3265749216079712) { - if (averageDuration_2 <= 0.5176114439964294) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3133423328399658) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.36834917962551117) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (numDurations_2 <= -1.837222695350647) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7714039981365204) { - if (averageDuration_2 <= 0.4220243841409683) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7889449000358582) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (maxDuration_2 <= 0.5027389526367188) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.8395034074783325) { - if (maxDuration_2 <= 0.38479121029376984) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3715471029281616) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7362314164638519) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (averageDuration_2 <= 0.892030268907547) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= 0.3501546233892441) { - if (maxDuration_2 <= 0.3567013442516327) { - if (averageDuration_2 <= -0.05101020261645317) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3091809153556824) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (maxDuration_2 <= 0.787327378988266) { - if (averageDuration_2 <= 0.8451510369777679) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.5353574752807617) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7298338711261749) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7450264692306519) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.03769860789179802) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 0.8056840002536774) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486204206943512) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486041784286499) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7353557646274567) { - if (maxDuration_2 <= 0.05073441565036774) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.9514381587505341) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= 0.8107065260410309) { - if (averageDuration_2 <= 0.4237384796142578) { - if (maxDuration_2 <= 0.4866992235183716) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - if (maxDuration_2 <= 0.06992466002702713) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7915673553943634) { - if (averageDuration_2 <= 0.538516640663147) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9137649834156036) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= 1.214015245437622) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (averageDuration_2 <= 0.5769166648387909) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.764543205499649) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (averageDuration_2 <= 0.6553438603878021) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - if (maxDuration_2 <= 0.49957050383090973) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7303033471107483) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - if (maxDuration_2 <= 0.7126586139202118) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3501206636428833) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 0.6066030561923981) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3385461568832397) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - if (maxDuration_2 <= 0.8123276233673096) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.5048055648803711) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.9083105623722076) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= 1.547933042049408) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.5942425429821014) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (averageDuration_2 <= 0.6103363335132599) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= 1.297077476978302) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7167105674743652) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 1.324093997478485) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6369636058807373) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3388392329216003) { - if (maxDuration_2 <= 0.8830580115318298) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.17070535570383072) { - if (maxDuration_2 <= 0.03542421758174896) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7167170643806458) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3300318717956543) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 1.0195274949073792) { - if (maxDuration_2 <= 0.5346001088619232) { - if (numDurations_2 <= -1.837222695350647) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7039747536182404) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7192570865154266) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.4277103394269943) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3781013488769531) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7082774341106415) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7188273966312408) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 0.7527487874031067) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - if (averageDuration_2 <= 1.6634626984596252) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3042593598365784) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.7694137394428253) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7190191149711609) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.428335964679718) { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.714835524559021) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6820487082004547) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - if (maxDuration_2 <= -0.006968073081225157) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.18870142102241516) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 0.5917955040931702) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { - if (maxDuration_2 <= -0.016516088973730803) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.6384455859661102) { - if (averageDuration_2 <= -0.061506884172558784) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0250356197357178) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1139658093452454) { - if (maxDuration_2 <= 0.284985676407814) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2451224327087402) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486253082752228) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7283376455307007) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7481821775436401) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { - if (averageDuration_2 <= 0.06543360091745853) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.44417300820350647) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2644217610359192) { - if (maxDuration_2 <= 0.085449930280447) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485407888889313) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2682607173919678) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7762331068515778) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486195862293243) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1965546011924744) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.00672119262162596) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7285553514957428) { - if (maxDuration_2 <= 0.20962027460336685) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8312131464481354) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (maxDuration_2 <= 0.5823515057563782) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2617387175559998) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.248332142829895) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748622864484787) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= 0.2047244906425476) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7070249021053314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= -1.837222695350647) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5689606815576553) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.734384298324585) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.07333364337682724) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5663581192493439) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numMissedDeadlines_2 <= 0.4979674816131592) { - if (averageDuration_2 <= 0.030110999010503292) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6790743172168732) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1662045121192932) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7092773616313934) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.27777573466300964) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8088094294071198) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9252032339572906) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.053518569096922874) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5767443478107452) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (numDurations_2 <= -1.837222695350647) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1295673251152039) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.1186873316764832) { - if (maxDuration_2 <= 0.08950985223054886) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9589276909828186) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6793113052845001) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0632541012018919) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (averageDuration_2 <= 0.6980580389499664) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5522426068782806) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.04067927086725831) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.4450313597917557) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.42228297889232635) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.31924521923065186) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.373752474784851) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.8067479133605957) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0003452599048615) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5516719818115234) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3758608549833298) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.3809443712234497) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414793252945) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.20446494966745377) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6188088357448578) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.18066196143627167) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.20783467590808868) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2646302506327629) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.047407783567905426) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1578196287155151) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.15819264948368073) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.33223602175712585) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3787037134170532) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (maxDuration_2 <= 0.25562411546707153) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15024030953645706) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.058333855122327805) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.11745284497737885) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.005097192712128162) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.33699631690979) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.00303316116333) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= 0.23250066488981247) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 1.1464404463768005) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 0.21996638923883438) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.177801489830017) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 0.44097670912742615) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.28779345750808716) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.382149577140808) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.40310265123844147) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3118772506713867) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.15153032913804054) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1118956804275513) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.07619240134954453) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.15163606498390436) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.24098747223615646) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9475547671318054) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5140326619148254) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.122046113014221) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= 0.19655156880617142) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.781566321849823) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4447983354330063) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4924338161945343) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5655569732189178) { - if (averageDuration_2 <= 0.098821971565485) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15152712166309357) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5228261053562164) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - if (averageDuration_2 <= 0.5458563268184662) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.730016827583313) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.2170642614364624) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.02906990423798561) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.02856963872909546) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.238178312778473) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (maxDuration_2 <= 0.32679012417793274) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7204974591732025) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= -1.837222695350647) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.7477512061595917) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7880737483501434) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 1.1180845499038696) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (numMissedDeadlines_2 <= 0.4979674816131592) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.9083105623722076) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= -1.837222695350647) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.690912663936615) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.8955870866775513) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.4177898168563843) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6933403313159943) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 0.5600239932537079) { - if (maxDuration_2 <= 0.4898955076932907) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - if (averageDuration_2 <= 0.6105079054832458) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6104522347450256) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7122949957847595) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { - if (maxDuration_2 <= 0.6768385767936707) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (averageDuration_2 <= 0.3958906829357147) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 0.7625952661037445) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2243144512176514) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 1.220582902431488) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.1602861285209656) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.814079612493515) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.910700649023056) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= 0.5329816937446594) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.648058295249939) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4057249426841736) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0356513261795044) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7177809476852417) { - if (numDurations_2 <= -1.837222695350647) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.8228538036346436) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2029322981834412) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5269411504268646) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.024478145875036716) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.45097780227661133) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1932070329785347) { - if (averageDuration_2 <= 0.9761073887348175) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.011000759899616241) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057841777802) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { - if (averageDuration_2 <= 0.7880142033100128) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.373752474784851) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2888569235801697) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616374969482422) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1707926988601685) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9593591094017029) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2780311852693558) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.05159341171383858) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617928862571716) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.2677568793296814) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617889523506165) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.030746312346309423) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.286307215690613) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numMissedDeadlines_2 <= 0.4979674816131592) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.22667479515075684) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7833147644996643) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.929038792848587) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.385517880320549) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4462291747331619) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.41568124294281) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4620673656463623) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.460362434387207) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3139577805995941) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1886991262435913) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.033895581960678) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (maxDuration_2 <= 0.2860620766878128) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4849824011325836) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.657949298620224) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6269091367721558) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= -1.837222695350647) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.783094972372055) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1779231429100037) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.13689523935318) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.2911977767944336) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.021669305860996246) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.8154819309711456) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 0.9102014303207397) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= 0.22145304828882217) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.380356550216675) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 0.8965803384780884) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.019650638103485) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.170151710510254) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351780652999878) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618065357208252) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.031726360321045) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8021548986434937) { - if (averageDuration_2 <= 0.19217464327812195) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2961706221103668) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.38952675461769104) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5133434683084488) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.46319472789764404) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= 0.2990090548992157) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6227197498083115) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5991550087928772) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3670244216918945) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.699196070432663) { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (averageDuration_2 <= 0.7871937155723572) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7223055958747864) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 1.5531962513923645) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (maxDuration_2 <= 0.8816423714160919) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.3247819542884827) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2898950576782227) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5729213654994965) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4596960544586182) { - if (maxDuration_2 <= 0.7243494391441345) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.516703724861145) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5253596305847168) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.3021210432052612) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.582572817802429) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.16512469202280045) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.359485849738121) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.10414645820856094) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0496952533721924) { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3159325122833252) { - if (maxDuration_2 <= 0.44848354160785675) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - if (averageDuration_2 <= 0.11518798395991325) { - if (maxDuration_2 <= 0.3707425892353058) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 0.025949942879378796) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4740087240934372) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6412768661975861) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (maxDuration_2 <= 0.707306981086731) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.71396803855896) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= 0.09735488146543503) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7376724183559418) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.5833165347576141) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { - if (averageDuration_2 <= 0.40346167981624603) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= 0.1455988883972168) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3750118017196655) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7479744851589203) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= 0.3382798433303833) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8841897249221802) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - if (averageDuration_2 <= 0.4573909193277359) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.772458016872406) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7350341081619263) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 0.3439282029867172) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3177205920219421) { - if (averageDuration_2 <= 0.3965920954942703) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7781811356544495) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3947518467903137) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.1614854633808136) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.1602861285209656) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7318580746650696) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - if (maxDuration_2 <= 0.7335355281829834) { - if (averageDuration_2 <= -0.22358045727014542) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.18644369393587112) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { - if (averageDuration_2 <= -0.10436297208070755) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - if (maxDuration_2 <= 0.6476949453353882) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6370158791542053) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7460389733314514) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 0.4726207107305527) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6254860162734985) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7479088604450226) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8777644336223602) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (averageDuration_2 <= 0.25544995069503784) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.276338279247284) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.8651829361915588) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7482175230979919) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8190293312072754) { - if (maxDuration_2 <= 0.40889255702495575) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2160131931304932) { - if (averageDuration_2 <= 0.35561203956604004) { - if (maxDuration_2 <= 0.38028834760189056) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (averageDuration_2 <= -0.33521825075149536) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 1.5776891708374023) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= -0.12976674735546112) { - if (averageDuration_2 <= -0.11710859835147858) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.38294506072998047) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.43432772159576416) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 0.43938523530960083) { - if (maxDuration_2 <= 0.22152647376060486) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (averageDuration_2 <= -0.32574252784252167) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.44835247099399567) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7307056486606598) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.20909659564495087) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= -0.02430170215666294) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (averageDuration_2 <= -0.2258094772696495) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9074200093746185) { - if (averageDuration_2 <= -0.16923687607049942) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.661981076002121) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.22411730885505676) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8436429798603058) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { - if (maxDuration_2 <= 0.5148426294326782) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8628608286380768) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3248445391654968) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.881703108549118) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3696222305297852) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.0791362039744854) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8676047325134277) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3087275624275208) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= 0.23027871549129486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3503610491752625) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3935490250587463) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 0.23482635617256165) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (maxDuration_2 <= 0.4805929362773895) { - if (maxDuration_2 <= 0.4179595708847046) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 0.04118461534380913) { - if (maxDuration_2 <= 0.5693234205245972) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - if (maxDuration_2 <= 0.48593440651893616) { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.19561199098825455) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (averageDuration_2 <= -0.10448626428842545) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.6849940121173859) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7117085158824921) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.10530847683548927) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8815761804580688) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 1.5776891708374023) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.405566155910492) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.6052596867084503) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= 0.4905616492033005) { - if (numDurations_2 <= -0.12976674735546112) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.355560064315796) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - if (maxDuration_2 <= 0.5339010953903198) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486025393009186) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.8635222911834717) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6903096735477448) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2868466973304749) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1538190245628357) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.7840677797794342) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.165454089641571) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7340164184570312) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.7063775658607483) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.7445275783538818) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.610241025686264) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5924471020698547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 1.008537232875824) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.188034474849701) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (maxDuration_2 <= 0.9008679687976837) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 0.43938523530960083) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7008077502250671) { - if (averageDuration_2 <= 0.2643844336271286) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - if (maxDuration_2 <= 0.6955349445343018) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.7134893834590912) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.5578047037124634) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2662665247917175) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.22989191114902496) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5977491438388824) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7541024386882782) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.10216920077800751) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.42361027002334595) { - if (maxDuration_2 <= 0.4239722043275833) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (averageDuration_2 <= -0.5200619399547577) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - if (averageDuration_2 <= -0.2242160066962242) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.43113580346107483) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.37682855129241943) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.9915950894355774) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.0460976362228394) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (maxDuration_2 <= 0.2023642659187317) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3809054344892502) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0422356091439724) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07928326725959778) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.11036526411771774) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.48583483695983887) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 0.43938523530960083) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4492810219526291) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.352176234126091) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5094962418079376) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.16918937116861343) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486220300197601) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7807817161083221) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.11793366447091103) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.1885876655578613) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.17433276772499084) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.5426415205001831) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.11077719926834106) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= 0.2160230204463005) { - if (averageDuration_2 <= -0.31468233466148376) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.22359083592891693) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.05851230211555958) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3163090348243713) { - if (maxDuration_2 <= 0.05643293261528015) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0394643247127533) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8886953592300415) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.13277871906757355) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.6861437559127808) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7507262825965881) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9234356880187988) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19263297319412231) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.55570387840271) { - if (maxDuration_2 <= 0.1708017811179161) { - if (averageDuration_2 <= -0.5610251128673553) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.42362651228904724) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6677180528640747) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5612044632434845) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5631475150585175) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.584723174571991) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (averageDuration_2 <= -0.2889907509088516) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.233017198741436) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.24158674478530884) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8876707553863525) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.528399646282196) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (averageDuration_2 <= -0.49200408160686493) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2125556841492653) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.29250966012477875) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.20429229736328125) { - if (numMissedDeadlines_2 <= 0.4979674816131592) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7477016150951385) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5334058552980423) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6653278172016144) { - if (averageDuration_2 <= -0.4260232597589493) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5648250579833984) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2818209081888199) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6487173736095428) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.2940475642681122) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4196433573961258) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - if (maxDuration_2 <= 0.1861371099948883) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (maxDuration_2 <= 0.019673330709338188) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (maxDuration_2 <= 0.3337070345878601) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= 0.4869145452976227) { - if (averageDuration_2 <= -0.6770841181278229) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.2920006066560745) { - if (maxDuration_2 <= 0.18673480302095413) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.540889710187912) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.10507988184690475) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.406888023018837) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2121511697769165) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.20364166051149368) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (averageDuration_2 <= -0.4976615309715271) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.35733550786972046) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.30065111815929413) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8286776542663574) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.42319174110889435) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.861069530248642) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.4454152584075928) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485148012638092) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37531453371047974) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5140326619148254) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.24337542802095413) { - if (maxDuration_2 <= 0.48002055287361145) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.6374476552009583) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22205941379070282) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - if (numMissedDeadlines_2 <= 0.4979674816131592) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.39401544630527496) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.528232216835022) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.1794498860836029) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3159213364124298) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= 0.11389721930027008) { - if (averageDuration_2 <= -0.18236665427684784) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.338785767555237) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.14361665770411491) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.06844793073832989) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.2011863961815834) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3089614361524582) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.19331497699022293) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - if (averageDuration_2 <= -0.13986914604902267) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (averageDuration_2 <= -0.1270977184176445) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - if (maxDuration_2 <= 0.018174038268625736) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6691918671131134) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7537937164306641) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { - if (averageDuration_2 <= -0.13090690970420837) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5896276533603668) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3457433432340622) { - if (maxDuration_2 <= 0.042670199647545815) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6201915442943573) { - if (maxDuration_2 <= 0.029588956385850906) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.26812171190977097) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.1930236667394638) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.34444981813430786) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4185460954904556) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.3677852749824524) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4051479548215866) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6271812617778778) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.020114105194807053) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4369344413280487) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6647421419620514) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.9805451035499573) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.4181138873100281) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.10518837906420231) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41206733882427216) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3919961005449295) { - if (maxDuration_2 <= 0.2993737459182739) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.62191441655159) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (averageDuration_2 <= -0.0283217616379261) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5045276582241058) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6544688940048218) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.028121292591095) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0722964107990265) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5934527516365051) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (maxDuration_2 <= 0.1890699863433838) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8431459367275238) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.023522169329226017) { - if (maxDuration_2 <= 0.2123681977391243) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5824819803237915) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7272729873657227) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7486220300197601) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (numDurations_2 <= -0.12976674735546112) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 0.6270053386688232) { - if (maxDuration_2 <= 0.3855106383562088) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 0.21966499835252762) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.13653941452503204) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= 0.3276115953922272) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (maxDuration_2 <= 0.6443189680576324) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.47222697734832764) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.046361858025193214) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.01598227908834815) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.5216022729873657) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.9378779828548431) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.36952340602874756) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3190089911222458) { - if (averageDuration_2 <= 0.1175558790564537) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6552557647228241) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6252796947956085) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17310208082199097) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7450781762599945) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7064080834388733) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 0.44583430886268616) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3183697760105133) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.19352737814188004) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 0.24251005798578262) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15201273560523987) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.15569567680358887) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8039239048957825) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.016184553503990173) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 0.06512174010276794) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.8923840522766113) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.35917940735816956) { - if (maxDuration_2 <= 0.21530620008707047) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= 0.356185644865036) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.21174664795398712) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.802529454231262) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.0760540664196014) { - if (maxDuration_2 <= 0.31688226759433746) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.3448770344257355) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07749074697494507) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4011481702327728) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.212310254573822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= 0.15889321267604828) { - if (numDurations_2 <= 1.5776891708374023) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= 0.04724868945777416) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - if (maxDuration_2 <= 0.48593683540821075) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.675391674041748) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3441346138715744) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6100157201290131) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06244405545294285) { - if (numDurations_2 <= 1.008537232875824) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= 0.22009800374507904) { - if (averageDuration_2 <= -0.39745883643627167) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4197363257408142) { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.372219517827034) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1875467672944069) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.46171484887599945) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.14265850186347961) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6042692363262177) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6698351800441742) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.620763510465622) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.48034273087978363) { - if (maxDuration_2 <= 0.0715835653245449) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - if (maxDuration_2 <= 0.012776992283761501) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (averageDuration_2 <= -0.6418242454528809) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.663274109363556) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.44426916539669037) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.933671712875366) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4070816785097122) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0722964107990265) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.889031320810318) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5188502371311188) { - if (averageDuration_2 <= -0.8325169086456299) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.597811222076416) { - if (maxDuration_2 <= 0.1663769856095314) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3882742077112198) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.20815537124872208) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4628823399543762) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.6319969296455383) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2213319540023804) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.787463665008545) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0509639978408813) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.41697587072849274) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6973564922809601) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.029960347339510918) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616639018058777) { - if (maxDuration_2 <= 0.06132879853248596) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9125365614891052) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.46271812915802) { - if (maxDuration_2 <= 0.20561867207288742) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.19302021712064743) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0102983713150024) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (numDurations_2 <= 8.122936725616455) { - if (averageDuration_2 <= -0.5750274062156677) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07656121999025345) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1900343298912048) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.50892436504364) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5622147917747498) { - if (maxDuration_2 <= 0.19127612560987473) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.154384046792984) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4577379822731018) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6384816765785217) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.347765564918518) { - if (maxDuration_2 <= 0.08196248486638069) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.0907738097012043) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4899015426635742) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6776856184005737) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.15501796454191208) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= 0.17161481082439423) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9723939001560211) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6053559482097626) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8988293707370758) { - if (averageDuration_2 <= -0.2605019360780716) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.12344541028141975) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.539192795753479) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18220101296901703) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (averageDuration_2 <= 0.09229308366775513) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3340485244989395) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.2049425840377808) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.11059711873531342) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1161888241767883) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.15582146495580673) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1814829558134079) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.08851968124508858) { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.1939581111073494) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485889792442322) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5335296094417572) { - if (averageDuration_2 <= -0.004776094370754436) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142840951681) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1707926392555237) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (averageDuration_2 <= -0.010463987477123737) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (averageDuration_2 <= -0.23142240941524506) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - if (averageDuration_2 <= -0.1066918708384037) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.013304732274264097) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.5074199438095093) { - if (averageDuration_2 <= -0.16805126518011093) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0628843903541565) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7221470475196838) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.4765240550041199) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.33063115179538727) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.086323320865631) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1928851455450058) { - if (averageDuration_2 <= -0.17536146938800812) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0436993483453989) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.661136656999588) { - if (averageDuration_2 <= -0.23615023493766785) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.1379606127738953) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9475547671318054) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.0335981510579586) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5396402776241302) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.30496281385421753) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4621602296829224) { - if (maxDuration_2 <= 0.020542078651487827) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5013982802629471) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6005529761314392) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7560848295688629) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5370949804782867) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.45300357043743134) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.18895867466926575) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.34293997287750244) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08552069030702114) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795315980911) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.37234041281044483) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.03144307155162096) { - if (maxDuration_2 <= 0.0597076490521431) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.08216270059347153) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.9797444343566895) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.25455667078495026) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (averageDuration_2 <= -0.10221527144312859) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23112794011831284) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2424963042140007) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.031810143031179905) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616052508354187) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.28017035126686096) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5334944427013397) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.42429259419441223) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11888782680034637) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.46158766746521) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2470339685678482) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5389856398105621) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4483988285064697) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - if (averageDuration_2 <= -0.3184443265199661) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.5414674282073975) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.696106195449829) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3612722158432007) { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.15628795325756073) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (maxDuration_2 <= 0.12875136733055115) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.13689523935318) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.465725600719452) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.027400558814406395) { - if (maxDuration_2 <= -0.011281084269285202) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (maxDuration_2 <= 0.012500862590968609) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6191794276237488) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6222433745861053) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (averageDuration_2 <= -0.2793334722518921) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.04933263547718525) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.49071481823921204) { - if (averageDuration_2 <= -0.09476756677031517) { - if (averageDuration_2 <= -0.11289915442466736) { - if (maxDuration_2 <= -0.01811185199767351) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.33371785283088684) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.3255345225334167) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.26727765798568726) { - if (numDurations_2 <= 0.439385250210762) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7961263060569763) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.466281533241272) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2898950576782227) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.129709839820862) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - if (maxDuration_2 <= 0.12367341294884682) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.07971153035759926) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4450399875640869) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.47418642044067383) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9398446679115295) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6658473610877991) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8647918701171875) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.09823410212993622) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= 0.007838984485715628) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4149242043495178) { - if (averageDuration_2 <= -0.2525296211242676) { - if (numDurations_2 <= 3.8542970418930054) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.4869600981473923) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.012821516953408718) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.37432676553726196) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.953914225101471) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.8782627880573273) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.024194462224841118) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2037067413330078) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2499517798423767) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.41048693656921387) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.392783522605896) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.338785767555237) { - if (averageDuration_2 <= 0.03958638198673725) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3128224015235901) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4028155654668808) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.0620607640594244) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522207856178284) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4014365077018738) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.675937294960022) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.32650475203990936) { - if (maxDuration_2 <= 0.4944039434194565) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.9437862634658813) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.805366575717926) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.5634624361991882) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5557366609573364) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.0224738121032715) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.9391517043113708) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.9914973974227905) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5415807664394379) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.061789870262146) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8963220119476318) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.1580029129981995) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.21383938938379288) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8347486853599548) { - if (maxDuration_2 <= 0.33199237287044525) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3509410172700882) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.39341555535793304) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.062060766853392124) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.585026204586029) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.19759371131658554) { - if (maxDuration_2 <= 0.3736323416233063) { - if (maxDuration_2 <= 0.3646717220544815) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0596327185630798) { - if (averageDuration_2 <= 0.5192143619060516) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.62141352891922) { - if (averageDuration_2 <= 0.03331002208869904) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.10090456902980804) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.46122559905052185) { - if (averageDuration_2 <= 9.826594032347202e-05) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7822611629962921) { - if (maxDuration_2 <= 0.3871721923351288) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5048755556344986) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6239155530929565) { - if (averageDuration_2 <= -0.16944565623998642) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 0.43938523530960083) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.8017890453338623) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= 0.031021786853671074) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.14722063392400742) { - if (averageDuration_2 <= -0.5394869148731232) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.7156547605991364) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.308888018131256) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.49859820306301117) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= 0.13941966742277145) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - if (cpuCoreIdleTimesPercentage_0_2 <= -3.0809937715530396) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.5989913046360016) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { - if (averageDuration_2 <= -0.3669191747903824) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3759192228317261) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= 0.13671940565109253) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.9914973974227905) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6395457684993744) { - if (averageDuration_2 <= 0.05797412618994713) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.07076146081089973) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.7789206802845001) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6416168510913849) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.3864171952009201) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.06816822290420532) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3176411986351013) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 0.7096243500709534) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.22129100561141968) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2785116583108902) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= 0.04537664353847504) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.38049250841140747) { - if (averageDuration_2 <= -0.33585256338119507) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.29331816732883453) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.06767088919878006) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3649323731660843) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7112196683883667) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.06686148978769779) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.16349100321531296) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (maxDuration_2 <= 0.3998432457447052) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22290639579296112) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.4449331909418106) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4779637455940247) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= 0.24680515378713608) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746561765671) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= 0.5888555347919464) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5462443828582764) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5530214309692383) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= 0.3146580904722214) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0318717956542969) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.1039646752178669) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.4881414920091629) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2536149173974991) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 1.5776891708374023) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.6127548217773438) { - if (averageDuration_2 <= -0.7499710917472839) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.3811798691749573) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4546968638896942) { - if (averageDuration_2 <= -0.019667698070406914) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619647860527039) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.41725030541419983) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.13962948322296143) { - if (numDurations_2 <= 1.008537232875824) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.286426067352295) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - if (maxDuration_2 <= 0.6470237970352173) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.40705400705337524) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.10518838092684746) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5549438744783401) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4620205163955688) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6365022361278534) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= 0.3078770190477371) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.462527573108673) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7406275272369385) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.33277831971645355) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - if (averageDuration_2 <= -0.049672285094857216) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.645479142665863) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.41269639134407043) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.19533181935548782) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4623185396194458) { - if (averageDuration_2 <= -0.06643534451723099) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.0005051215412095189) { - if (averageDuration_2 <= -0.12774206697940826) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.6900644302368164) { - if (numDurations_2 <= 1.5776891708374023) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8038868010044098) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.029591891914606094) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6085982918739319) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.18870143964886665) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.27833783626556396) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= 0.11755884811282158) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (numDurations_2 <= -0.6989187151193619) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.44290691614151) { - if (numDurations_2 <= 0.43938523530960083) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.9594480991363525) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.29277460277080536) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386043190956116) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.36024706065654755) { - if (maxDuration_2 <= 0.2841472625732422) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7421627342700958) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4433463215827942) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6678047180175781) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3235849142074585) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.020337074995041) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5741706788539886) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.36193178594112396) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1692101955413818) { - if (averageDuration_2 <= -0.23646488785743713) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.7322489023208618) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.06666266918182373) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4434637427330017) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.09044719114899635) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.3182220757007599) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612554907798767) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.0768701396882534) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.2368706464767456) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2656935304403305) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.27072834968566895) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 1.5776891708374023) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.41234298050403595) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.031911457888782024) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.04981585964560509) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.2395479381084442) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1345600076019764) { - if (maxDuration_2 <= 0.28496788442134857) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8463237583637238) { - if (averageDuration_2 <= -0.1146455891430378) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5720092058181763) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37376396358013153) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7290521264076233) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.5594106465578079) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 0.16038391180336475) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 0.43938523530960083) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.34959374368190765) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4358084797859192) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= 0.4705762565135956) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= 0.2977922409772873) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149006992578506) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.6335321068763733) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.667253613471985) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.4268258810043335) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2672328352928162) { - if (maxDuration_2 <= 1.2397143244743347) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2908948063850403) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - if (averageDuration_2 <= -0.1147768460214138) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6963140666484833) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7137441039085388) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7367220520973206) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8951284289360046) { - if (maxDuration_2 <= 1.0347838997840881) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - if (averageDuration_2 <= 0.4940515458583832) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 1.0273380875587463) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6439265310764313) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - if (averageDuration_2 <= 0.8747955858707428) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.333996832370758) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - if (numDurations_2 <= 2.7159931659698486) { - if (averageDuration_2 <= 0.058744143694639206) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7248106896877289) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 1.0508134961128235) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3808841109275818) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - if (maxDuration_2 <= 0.9993820488452911) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 1.2154080867767334) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 2.0939146280288696) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3406645059585571) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 1.1494845747947693) { - if (averageDuration_2 <= 1.6962002515792847) { - if (averageDuration_2 <= 1.2984217405319214) { - if (averageDuration_2 <= 0.8297915756702423) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8542903363704681) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7063393294811249) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7245881259441376) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3326250314712524) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6553433537483215) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.3316137790679932) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.82205531001091) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7211807370185852) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6782130897045135) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - if (maxDuration_2 <= 1.1487780213356018) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - if (averageDuration_2 <= 0.7705576121807098) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7121440172195435) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7301165461540222) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.698575496673584) { - if (maxDuration_2 <= 0.9817012250423431) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7657250165939331) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 1.0006634891033173) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.997178465127945) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7803223729133606) { - if (averageDuration_2 <= 0.4392378032207489) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7227019965648651) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.2025296092033386) { - if (averageDuration_2 <= 1.17425936460495) { - if (averageDuration_2 <= -0.4650510251522064) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.0644025206565857) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3543331176042557) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.232117474079132) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.6321735382080078) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.2925446033477783) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.622730255126953) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8465102016925812) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8867943286895752) { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7353781759738922) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= 1.3574286699295044) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - if (averageDuration_2 <= 0.08344195038080215) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 0.06531268544495106) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8196530342102051) { - if (averageDuration_2 <= 2.228592276573181) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7789277136325836) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6993706524372101) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (maxDuration_2 <= 3.127223253250122) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5881697237491608) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (maxDuration_2 <= 4.750869274139404) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.5675472021102905) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.5068358182907104) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 1.4013153910636902) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.5397977828979492) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2699247002601624) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= -0.12976674735546112) { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 4.555438995361328) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.15159282833337784) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1527207493782043) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7358740270137787) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.320826455950737) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2158499956130981) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.07188973762094975) { - if (averageDuration_2 <= 0.3709491342306137) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (averageDuration_2 <= 0.34653453528881073) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.8759267926216125) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.08240407705307) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12969237938523293) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2014800310134888) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.259523630142212) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 0.15480925142765045) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4981125742197037) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.4836897253990173) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.1574791073799133) { - if (maxDuration_2 <= 1.435587465763092) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9154582917690277) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 1.0432456731796265) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3449762463569641) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (maxDuration_2 <= 1.4485169649124146) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6885486245155334) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6886526048183441) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2565064430236816) { - if (maxDuration_2 <= 0.9501186609268188) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.1182125806808472) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6380338668823242) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.17278318852186203) { - if (averageDuration_2 <= -0.17343050986528397) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.1427316665649414) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.075559675693512) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.3159748911857605) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.08230776339769363) { - if (averageDuration_2 <= -0.08253948763012886) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 9.801794052124023) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.19193264842033386) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6280999481678009) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.6451153755187988) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5406005382537842) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.18271947279572487) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= 1.3693780303001404) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -1.2194320559501648) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.2480701804161072) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5723515450954437) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23277811706066132) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396028995514) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7952302098274231) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7142362892627716) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7485400140285492) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.399832308292389) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461732268333435) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.4554807543754578) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0973148345947266) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= 1.2440527081489563) { - if (averageDuration_2 <= 1.73860764503479) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.0055207312107086) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.252377524971962) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.3084317445755005) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= 1.0621952414512634) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.9162233769893646) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.3711637258529663) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2889532446861267) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5404995977878571) { - if (averageDuration_2 <= 0.03363163024187088) { - if (maxDuration_2 <= 5.442666530609131) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.17533350735902786) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.019098293036222458) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15313415229320526) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.07682698452845216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7273778319358826) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0403966903686523) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.33660896122455597) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.24161361157894135) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.12640953436493874) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.18711814284324646) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1658167615532875) { - if (numDurations_2 <= -0.12976674735546112) { - if (maxDuration_2 <= 1.0377017259597778) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 1.4347721934318542) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.437980055809021) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 1.114682912826538) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.28755907714366913) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.9446317553520203) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.9720517694950104) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.009847766952589154) { - if (maxDuration_2 <= 0.9507694244384766) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 1.0623169541358948) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 1.008537232875824) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.3506556302309036) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.0572593212127686) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.667253613471985) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06506203301250935) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.13083729892969131) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.05861735716462135) { - if (averageDuration_2 <= 1.2439587712287903) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4534569382667542) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 4.728882312774658) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 8.271708488464355) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= -1.837222695350647) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.08376500755548477) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.014264244586229324) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.07696647383272648) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 4.234511375427246) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= 1.9694133400917053) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9057248532772064) { - if (averageDuration_2 <= -0.34881260991096497) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 0.43938523530960083) { - if (maxDuration_2 <= 1.0196890830993652) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.0258170664310455) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 1.047807216644287) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4246694892644882) { - if (averageDuration_2 <= -0.03377376776188612) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.42365574836730957) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2641832232475281) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.10438440088182688) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.654310792684555) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= 0.4608350396156311) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1218477338552475) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 1.4003121852874756) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.17989181727170944) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.0923520177602768) { - if (maxDuration_2 <= 7.748300313949585) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.16987980157136917) { - if (maxDuration_2 <= 5.502759695053101) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2760445326566696) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9963940382003784) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.19346007704734802) { - if (averageDuration_2 <= 3.581660270690918) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.495326966047287) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 5.497339487075806) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3789841532707214) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.21568135917186737) { - if (maxDuration_2 <= 4.041155576705933) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5587422549724579) { - if (averageDuration_2 <= 1.8233594298362732) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5767306089401245) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306547224521637) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5069313049316406) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5490114688873291) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0255975890904665) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09108610451221466) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9738001227378845) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.47177310287952423) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6598487496376038) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6908779740333557) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.20580721646547318) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1277656927704811) { - if (averageDuration_2 <= -0.042279867455363274) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.49306267499923706) { - if (averageDuration_2 <= -0.5489812791347504) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07994036376476288) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4251624047756195) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5092168748378754) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6228834390640259) { - if (maxDuration_2 <= 2.3995301723480225) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27492596209049225) { - if (averageDuration_2 <= 0.7995809614658356) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.20815537124872208) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.36848193407058716) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { - if (averageDuration_2 <= 0.2559853494167328) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= 2.031608462333679) { - if (averageDuration_2 <= -0.31484147906303406) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7692394852638245) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.493299663066864) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4393751323223114) { - if (maxDuration_2 <= 1.1987935900688171) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2934441417455673) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5402822196483612) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= 0.03565223515033722) { - if (maxDuration_2 <= 1.4213740825653076) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821782171726) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5703529417514801) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 1.1997610926628113) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.19196250289678574) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.46887846291065216) { - if (maxDuration_2 <= 4.473825454711914) { - if (maxDuration_2 <= 3.26335072517395) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7360367178916931) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4981432259082794) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.01875431463122368) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 3.676967144012451) { - if (averageDuration_2 <= -0.0972072146832943) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6087082922458649) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= 3.9335360527038574) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1530905961990356) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (numDurations_2 <= 3.8542970418930054) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.10788631439209) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.1843433827161789) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 1.5372523665428162) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= 2.2581138610839844) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7942191362380981) { - if (maxDuration_2 <= 1.1155110597610474) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (averageDuration_2 <= -0.27747705578804016) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - if (averageDuration_2 <= 0.038410043343901634) { - if (maxDuration_2 <= 0.9718669950962067) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.49339374899864197) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.886878728866577) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.780944436788559) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3192542940378189) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9059016704559326) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.028396189212799) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.22025777399539948) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618202447891235) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3625665605068207) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 1.595767855644226) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.5629400014877319) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096855878829956) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2197190597653389) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6394426822662354) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.40631960332393646) { - if (averageDuration_2 <= -0.05224973149597645) { - if (numDurations_2 <= 6.700057029724121) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - if (maxDuration_2 <= 1.7121778726577759) { - if (maxDuration_2 <= 1.5087089538574219) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225883811712265) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.9304614961147308) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.8652614951133728) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 1.2522764205932617) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.28313285112381) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.39119021594524384) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= 0.3465253859758377) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473682403564) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7422017455101013) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3615803718566895) { - if (averageDuration_2 <= 0.8954007923603058) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.603843688964844) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.0446120500564575) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.9649280905723572) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.7825998663902283) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 1.711048424243927) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.4960829168558121) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7480331063270569) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 4.056646347045898) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 4.231687545776367) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.876897096633911) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.173550605773926) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2032031416893005) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.586751937866211) { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -3.035153388977051) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numMissedDeadlines_2 <= 4.563007950782776) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.463899254798889) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.2526502013206482) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.982878804206848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8448909521102905) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (averageDuration_2 <= 1.3239935636520386) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7619648277759552) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.5074199438095093) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.498723864555359) { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (maxDuration_2 <= 4.87779974937439) { - if (maxDuration_2 <= 2.3121676445007324) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.1321862936019897) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7348887622356415) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.4512444734573364) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.4935392141342163) { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.454002380371094) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.075559675693512) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4438839554786682) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.9139221906661987) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= 0.9661585986614227) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= 0.16788558661937714) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6907860934734344) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.7504844069480896) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.1833787560462952) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.31720077246427536) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.448194146156311) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.746365487575531) { - if (maxDuration_2 <= 0.9847912192344666) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620584785938263) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.234639286994934) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.4668562412261963) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.2249562740325928) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= 0.6445416212081909) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.5304139256477356) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4623048305511475) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4457237720489502) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.833759069442749) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4813186526298523) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.7582613229751587) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 0.36838899552822113) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.11492381989955902) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.5018715858459473) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.17073660343885422) { - if (averageDuration_2 <= 0.7805143892765045) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4246906116604805) { - if (maxDuration_2 <= 1.2258046865463257) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539695262909) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8041815161705017) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.5529089570045471) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 0.3759522885084152) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7460162043571472) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (maxDuration_2 <= 4.934912204742432) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8281188905239105) { - if (averageDuration_2 <= 0.7098559141159058) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.573121190071106) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3543576002120972) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.157832622528076) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 8.277822494506836) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.437980055809021) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= 0.6682068407535553) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.12303692102432251) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.349606215953827) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.953968048095703) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.337915778160095) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 0.21181511133909225) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 0.2224787175655365) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6447762846946716) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.5744774341583252) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5361003279685974) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= 2.1362669467926025) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.743943840265274) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.7946025133132935) { - if (maxDuration_2 <= 0.22033867985010147) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8963220119476318) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.188845932483673) { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.421170234680176) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4157383292913437) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.404264450073242) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.008243268355727196) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6746354103088379) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.2251909971237183) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.561257928609848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.38558030128479) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.06882278993725777) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.42461895942688) { - if (numDurations_2 <= 0.43938523530960083) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 0.5053845942020416) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.63319993019104) { - if (maxDuration_2 <= 0.9504174888134003) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7926430106163025) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.7295695543289185) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.027185082435608) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.5034048110246658) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= 0.5008799582719803) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.688767433166504) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.415175676345825) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (maxDuration_2 <= 0.2468533217906952) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.265189170837402) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.429135799407959) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.2464916706085205) { - if (maxDuration_2 <= 0.40787170827388763) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5502367317676544) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.0371131300926208) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 1.0754135847091675) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 1.437940537929535) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8223898708820343) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.748391330242157) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (maxDuration_2 <= 0.38711637258529663) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.58152174949646) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.6982106566429138) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (maxDuration_2 <= 0.0807366743683815) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6072250306606293) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.6362186670303345) { - if (averageDuration_2 <= -0.03426414728164673) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.9295657873153687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.4512444734573364) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4365596771240234) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - if (averageDuration_2 <= 0.354840487241745) { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.1415839195251465) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8322991132736206) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5589273571968079) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.2961843013763428) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.8948506116867065) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.9236379861831665) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= 0.1826794594526291) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -3.2103766202926636) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.22172657400369644) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.399782419204712) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.8780616521835327) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 1.9040824174880981) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.688767433166504) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.9639345407485962) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 0.43938523530960083) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.444998502731323) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= 0.24819854646921158) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4618651270866394) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.3048789501190186) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.17757216095924377) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7354914247989655) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.7386195361614227) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615622758865356) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (averageDuration_2 <= -0.18567488342523575) { - if (maxDuration_2 <= 0.3714416176080704) { - if (averageDuration_2 <= -0.42423610389232635) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.358581781387329) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (maxDuration_2 <= 1.869640290737152) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.111296832561493) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.735918045043945) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { - if (numDurations_2 <= 1.008537232875824) { - if (cpuCoreIdleTimesPercentage_0_2 <= -3.059429883956909) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.277944803237915) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.9649280905723572) { - if (averageDuration_2 <= 0.8997042775154114) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - if (numDurations_2 <= -0.12976674735546112) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615329504013062) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.25149397552013397) { - if (averageDuration_2 <= -0.406320720911026) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5075617134571075) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.925930917263031) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4623331427574158) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - if (averageDuration_2 <= 0.15022411197423935) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0674490332603455) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.1885876655578613) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.7263267040252686) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.06999514438211918) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.23222923278808594) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.9797444343566895) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.160470485687256) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.3761270195245743) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.381176233291626) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.677203357219696) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.112101793289185) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 0.5855295658111572) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6061519682407379) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.663274109363556) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.6321735382080078) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 0.18354304879903793) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { - if (averageDuration_2 <= -0.5602931082248688) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.37562336027622223) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8599216341972351) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.7782952785491943) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.02038021106272936) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.0900914072990417) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.8438576757907867) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2226265668869019) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3992462754249573) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.0406333208084106) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619892239570618) { - if (maxDuration_2 <= 0.09245289117097855) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.051824569702148) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.6982106566429138) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (averageDuration_2 <= -0.5625777542591095) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9638757109642029) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616668224334717) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6658473610877991) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8729664087295532) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.2630579322576523) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.1715557873249054) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.40520548820495605) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - if (averageDuration_2 <= -0.42834365367889404) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.0572593212127686) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.316119909286499) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.9126373529434204) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6286241710186005) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612310528755188) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.0664097368717194) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7346532046794891) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.21237558871507645) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - if (maxDuration_2 <= 5.134118556976318) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.0849900245666504) { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.3955165594816208) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 2.913347601890564) { - if (averageDuration_2 <= 1.18455171585083) { - if (maxDuration_2 <= 2.27710497379303) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.8780616521835327) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.6035331785678864) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.2615691423416138) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.2490766644477844) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.1853603571653366) { - if (averageDuration_2 <= 1.6916465163230896) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.16008039563894272) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 1.5776891708374023) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.4590892791748047) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 4.585613012313843) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.0654605627059937) { - if (maxDuration_2 <= 4.9905173778533936) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.6866998672485352) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5427366495132446) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.5524985790252686) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.558120250701904) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.4576098918914795) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.853458523750305) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= 0.11852159723639488) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - if (maxDuration_2 <= 2.418796420097351) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.6482369899749756) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7348887622356415) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.1251208782196045) { - if (maxDuration_2 <= 2.733711361885071) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.0849900245666504) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.9133753776550293) { - if (averageDuration_2 <= 0.8541741371154785) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -5.099122047424316) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= 0.17506881058216095) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= 4.443344593048096) { - if (averageDuration_2 <= 0.09622830152511597) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.2663294076919556) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.6967872381210327) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.3601619005203247) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -3.1672489643096924) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2132534384727478) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 0.7079232633113861) { - if (cpuCoreIdleTimesPercentage_6_2 <= -4.783979892730713) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.5427379608154297) { - if (numDurations_2 <= 1.008537232875824) { - if (averageDuration_2 <= 0.8650996685028076) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= -0.5710693895816803) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.09397531673312187) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.1618149280548096) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.139175176620483) { - if (cpuCoreIdleTimesPercentage_7_2 <= -4.134758949279785) { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (cpuCoreIdleTimesPercentage_7_2 <= -5.560335159301758) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -5.542833089828491) { - if (maxDuration_2 <= 1.4604384303092957) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.5074199438095093) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.0674948692321777) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.1562999486923218) { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.9340291023254395) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1277238726615906) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.6476744413375854) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9789374470710754) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4601836204528809) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.99435293674469) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.586751937866211) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.982967972755432) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0982938408851624) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -5.837942838668823) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.454709768295288) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.43490731716156) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.8912922143936157) { - if (averageDuration_2 <= -0.44667379558086395) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= 0.2391209974884987) { - if (averageDuration_2 <= -0.28988786041736603) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.111681342124939) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.2385960817337036) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616658091545105) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.7575366497039795) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.735918045043945) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.0422221422195435) { - if (averageDuration_2 <= -0.5562194883823395) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.3491384983062744) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.6747801303863525) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3431223630905151) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.3855801820755005) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.691397488117218) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.2226991280913353) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.2219114899635315) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4300630688667297) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.028396189212799) { - if (averageDuration_2 <= -0.563870757818222) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1844987869262695) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.663274109363556) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.2055274099111557) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4490292072296143) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4546351432800293) { - if (numDurations_2 <= 2.7159931659698486) { - if (maxDuration_2 <= 0.18363483995199203) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.346752107143402) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.6636706292629242) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.4826260060071945) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.430952250957489) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.893477201461792) { - if (maxDuration_2 <= 0.1935705617070198) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.6307660341262817) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.205713987350464) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.0897412300109863) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.851856768131256) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.4010435938835144) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.7210044860839844) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2661662846803665) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.5566930770874023) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.6307660341262817) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.4424600750207901) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.7706212997436523) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0725500583648682) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.218447744846344) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5387277007102966) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.2534535229206085) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 1.008537232875824) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.1251208782196045) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.4576098918914795) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.8025574684143066) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2577635645866394) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.0585830211639404) { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.092849254608154) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.2925446033477783) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.700800359249115) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.308637857437134) { - if (maxDuration_2 <= 0.6613157987594604) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.5074199438095093) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.812397599220276) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.9446317553520203) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.3486677557229996) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2447715997695923) { - if (maxDuration_2 <= 0.3762309104204178) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.011162791401147842) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9528200030326843) { - if (averageDuration_2 <= -0.39246559143066406) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.7930396795272827) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.808729112148285) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.13044001534581184) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.97426438331604) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6184161007404327) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.9812395572662354) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.987226366996765) { - if (cpuCoreIdleTimesPercentage_5_2 <= -5.132140636444092) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.791597366333008) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616882801055908) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.290977358818054) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.38967615365982056) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - if (maxDuration_2 <= 0.4418680667877197) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.180942177772522) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.4576098918914795) { - if (maxDuration_2 <= 1.2404944896697998) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.6415618658065796) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.8101627826690674) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.9373741149902344) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.8274345993995667) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (maxDuration_2 <= 0.7604022324085236) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.5652191638946533) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.599594235420227) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6628259122371674) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.5744280219078064) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.226507544517517) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.5192242860794067) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.1879565715789795) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.662456214427948) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -4.5731871128082275) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.1894078552722931) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.6793462634086609) { - if (maxDuration_2 <= 1.231391727924347) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.69642436504364) { - if (maxDuration_2 <= 0.6272156238555908) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.19283422827720642) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.7453612089157104) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8612625002861023) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4122499227523804) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.9446317553520203) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5842567980289459) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= 2.420959234237671) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.487790107727051) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= -0.6989187151193619) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.34082792699337006) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (maxDuration_2 <= 0.21765905618667603) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 5.732524633407593) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.9953776597976685) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.545638561248779) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.516908645629883) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118146881461143) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.8869194984436035) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 1.0929903388023376) { - if (cpuCoreIdleTimesPercentage_5_2 <= -5.00006628036499) { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.7182124853134155) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.6326003074645996) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 4.84874153137207) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -5.332040548324585) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.5018715858459473) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.5505964756011963) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7907134294509888) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.2925446033477783) { - if (maxDuration_2 <= 0.31979501247406006) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.31715816631913185) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5486325025558472) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.1475950479507446) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= 0.044032835867255926) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.23920727521181107) { - if (averageDuration_2 <= -0.5157760679721832) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.940490186214447) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.5613828897476196) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5878564715385437) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.4340621829032898) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.463899254798889) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.749365210533142) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { - if (maxDuration_2 <= 0.5469192564487457) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.0677136182785034) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9617350101470947) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.592329502105713) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7953336238861084) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.688767433166504) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07367007434368134) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= 0.2198650985956192) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.0538922548294067) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4596344828605652) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2987598180770874) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.477400466799736) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.15305794775485992) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.4840766191482544) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8952721953392029) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9559153914451599) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.11118209734559059) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5580283105373383) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.6843383312225342) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616599678993225) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5258576273918152) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.542178750038147) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3647471070289612) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.3800418376922607) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.015125670470297337) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5509052872657776) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5425611734390259) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.5676898658275604) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.06513400934636593) { - if (maxDuration_2 <= 0.49818260967731476) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5213649570941925) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.14346570521593094) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (averageDuration_2 <= -0.4903840124607086) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5562154948711395) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0082823038101196) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.2223153710365295) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0046014785766602) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.117706298828125) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6019871830940247) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.191977858543396) { - if (maxDuration_2 <= 0.750056266784668) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.287364959716797) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.23392348736524582) { - if (numDurations_2 <= 1.8622652292251587) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.645479142665863) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.6746354103088379) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.27841270714998245) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - if (averageDuration_2 <= -0.1397009715437889) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.7485665678977966) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.36117394268512726) { - if (averageDuration_2 <= -0.4706839770078659) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2249875664710999) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.442241072654724) { - if (averageDuration_2 <= -0.4147425442934036) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (maxDuration_2 <= 0.31923268735408783) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9304579496383667) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6949154138565063) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.0243793725967407) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4606691598892212) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.697882056236267) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 5.171576499938965) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.5115883648395538) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2634060978889465) { - if (maxDuration_2 <= 0.2689714729785919) { - if (averageDuration_2 <= -0.8843685388565063) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.0049888622015714645) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5653403401374817) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3740711212158203) { - if (maxDuration_2 <= -0.020862341858446598) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7406724989414215) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.781872272491455) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2829027771949768) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.476829707622528) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8633034825325012) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12482808530330658) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.03129708580672741) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9362237751483917) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.190671145915985) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9096425473690033) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236781001091003) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9985226392745972) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.06469383370131254) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8125279545783997) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.6519380807876587) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0108682513237) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4517258405685425) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5798149406909943) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.4151755571365356) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8599216341972351) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1908841133117676) { - if (averageDuration_2 <= -0.290820837020874) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9762081205844879) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.34099067747592926) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08570989221334457) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7601674497127533) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.18297383189201355) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8002705574035645) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9433919489383698) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22526995837688446) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.29162636399269104) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.09513238444924355) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.4736533761024475) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numMissedDeadlines_2 <= 0.4979674816131592) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.11780998483300209) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - if (averageDuration_2 <= -0.402012899518013) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8773755729198456) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6297035217285156) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6389772891998291) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1864543855190277) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9282219707965851) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2433997169137001) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0222047567367554) { - if (averageDuration_2 <= -0.23228415846824646) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.472960963845253) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (averageDuration_2 <= -0.23616617172956467) { - if (maxDuration_2 <= 0.10271772742271423) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5344285368919373) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5661364197731018) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.5304139256477356) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.24685662984848022) { - if (averageDuration_2 <= -0.15420926362276077) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2898950576782227) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= 0.09499573335051537) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.5047082901000977) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9299096465110779) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= 0.0377645269036293) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1265933513641357) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0370712280273438) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1459269067272544) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.127111554145813) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.0371131300926208) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (maxDuration_2 <= 1.426781415939331) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0279250144958496) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.31352490186691284) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (averageDuration_2 <= -0.14483404904603958) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (maxDuration_2 <= -0.00603093346580863) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.372219517827034) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.649102509021759) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8230292797088623) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (maxDuration_2 <= 4.5160605907440186) { - if (averageDuration_2 <= -0.18871399015188217) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.09280875325202942) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (maxDuration_2 <= 0.45623114705085754) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7385323941707611) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (maxDuration_2 <= 0.86497962474823) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - if (maxDuration_2 <= 2.9899936635047197e-05) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 2.346733570098877) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9327906668186188) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.437747836112976) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.22203048318624496) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4797641038894653) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3616790473461151) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.7634464502334595) { - if (numDurations_2 <= 3.8542970418930054) { - if (averageDuration_2 <= -0.22944680601358414) { - if (averageDuration_2 <= -0.5647774934768677) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - if (maxDuration_2 <= 0.27496108412742615) { - if (averageDuration_2 <= -0.7766503691673279) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.273658037185669) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.6456998586654663) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.8087291717529297) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.490656018257141) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.130564846098423) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { - if (averageDuration_2 <= -0.6203295588493347) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4296009540557861) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.9608718156814575) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5586740374565125) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.673958957195282) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4662640690803528) { - if (averageDuration_2 <= -0.7149122953414917) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.06767288595438004) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7952302098274231) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0276674628257751) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5010069161653519) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.12180086597800255) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.470812126994133) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.30836057662963867) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.05811327323317528) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.498723864555359) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.286965489387512) { - if (maxDuration_2 <= 0.20517290383577347) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.429601788520813) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= 0.21993084251880646) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2757284343242645) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7175521850585938) { - if (averageDuration_2 <= -0.4478025734424591) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.08609193190932274) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9801180064678192) { - if (maxDuration_2 <= 0.20576544106006622) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.27050212025642395) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9907727837562561) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.49218109250068665) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606539070606) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.023329058662056923) { - if (maxDuration_2 <= 0.005171212833374739) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5624487698078156) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.12173149362206459) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.068531036376953) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (averageDuration_2 <= -0.45919619500637054) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.24256665259599686) { - if (averageDuration_2 <= -0.2513412684202194) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (averageDuration_2 <= -0.2871234118938446) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9208987355232239) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7167382836341858) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8536417782306671) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.533635139465332) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { - if (averageDuration_2 <= -0.45020875334739685) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.978029489517212) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3819584399461746) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.20400115102529526) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= -0.026446903124451637) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.453211784362793) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4851459264755249) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.02546230424195528) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3351811021566391) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4413036108016968) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6801090836524963) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6783112287521362) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8963220119476318) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4427045583724976) { - if (averageDuration_2 <= -0.43924054503440857) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962230682373) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.7642477750778198) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6046839654445648) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3898805379867554) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.8397281467914581) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3439762592315674) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.48541775345802307) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4579831957817078) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4487749934196472) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (maxDuration_2 <= 0.0820510983467102) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.4503461122512817) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.590840458869934) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.4310784637928009) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9625294208526611) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9650612771511078) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.778005599975586) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7944058179855347) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.175323273986578) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3809148669242859) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.165417432785034) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5461384654045105) { - if (maxDuration_2 <= -0.015895698219537735) { - if (maxDuration_2 <= -0.02159938123077154) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.856436848640442) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613434076309204) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9753895998001099) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.27530206739902496) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0297358930110931) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.145269215106964) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.26463083922863007) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.3852008581161499) { - if (maxDuration_2 <= 0.015881985425949097) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.758753776550293) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= 0.9518231749534607) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.536037802696228) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.094433307647705) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.764528274536133) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.7930396795272827) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.644805073738098) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.35234886407852173) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.2808487117290497) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5306718051433563) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6811587810516357) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7076539397239685) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.11044968664646149) { - if (averageDuration_2 <= -0.3409472405910492) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17054980993270874) { - if (averageDuration_2 <= -0.2976961135864258) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5028862357139587) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (maxDuration_2 <= 0.3221554160118103) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.21358665823936462) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7382974028587341) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.29162636399269104) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.5886342525482178) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.2081451416015625) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.12936347723007202) { - if (maxDuration_2 <= 1.2196782231330872) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.0867060422897339) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8826817870140076) { - if (maxDuration_2 <= 2.057348370552063) { - if (averageDuration_2 <= -0.49007444083690643) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991199404001) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7363757789134979) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4977322518825531) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9319745302200317) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1469665989279747) { - if (maxDuration_2 <= 0.41644999384880066) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.4010436534881592) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.77295982837677) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7213721871376038) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.2966272830963135) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.33789683878421783) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6208008527755737) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (maxDuration_2 <= 0.38140007853507996) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 1.4863224625587463) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4474046975374222) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (averageDuration_2 <= -0.15581195056438446) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.31643857061862946) { - if (maxDuration_2 <= 0.34870821237564087) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (maxDuration_2 <= 0.006683351006358862) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.052487095817923546) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.2628925144672394) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= 0.6909483075141907) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= 1.6752436757087708) { - if (maxDuration_2 <= 0.22546987980604172) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3362553715705872) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.1025970578193665) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.1234295442700386) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.87017160654068) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5766326189041138) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8073097467422485) { - if (averageDuration_2 <= -0.16431204974651337) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.75286203622818) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (maxDuration_2 <= 0.20425356179475784) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.056215286254883) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0241283178329468) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (maxDuration_2 <= 0.01601620903238654) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7213721871376038) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (averageDuration_2 <= -0.11832256615161896) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6461236774921417) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.11668123304843903) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (maxDuration_2 <= 0.22366664558649063) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0980674028396606) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.21719423681497574) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.06051773577928543) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0903100967407227) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619384407997131) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2737065404653549) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3329706937074661) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.23303381353616714) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.8750420808792114) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5082814395427704) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.4770658016204834) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.4230196475982666) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5281223058700562) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.12008029595017433) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461566150188446) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4607601165771484) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.7139012813568115) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.0913562998175621) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9417820572853088) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2705117464065552) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3639540523290634) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9450945854187012) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.3708546161651611) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.1820899248123169) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5740392208099365) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461487054824829) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4622735977172852) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= 3.166913390159607) { - if (averageDuration_2 <= -0.22675766050815582) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (averageDuration_2 <= -0.44040344655513763) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32115907967090607) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.03816409781575203) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (maxDuration_2 <= 0.013002348132431507) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7576094269752502) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= 0.5923580229282379) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0903671532869339) { - if (maxDuration_2 <= 0.0044747485080733895) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5793808698654175) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.5861683487892151) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8475130796432495) { - if (averageDuration_2 <= -0.4562068432569504) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.13177035003900528) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7348887473344803) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.9953776597976685) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.610603392124176) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.07135216146707535) { - if (averageDuration_2 <= -0.5367028415203094) { - if (maxDuration_2 <= 0.24522492289543152) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.5694423615932465) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.44010692834854126) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.14138525724411) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (maxDuration_2 <= 0.1441781222820282) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.47702690958976746) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.09448360279202461) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= 0.22408954054117203) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.8208415508270264) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.142661690711975) { - if (numDurations_2 <= 4.992600917816162) { - if (averageDuration_2 <= -0.6455116271972656) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6802394390106201) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.204942524433136) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.6878583431243896) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6351950466632843) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.256135031580925) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.09055475145578384) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3481873869895935) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.5762049853801727) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5522465109825134) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461240828037262) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9215435981750488) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.91382372379303) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.1580028533935547) { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.379005551338196) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.302121102809906) { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0402230620384216) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.4106956720352173) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5319457650184631) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.6712300181388855) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2493237257003784) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.6858617663383484) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.215156376361847) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.702205240726471) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.7625550329685211) { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.048900008201599) { - if (maxDuration_2 <= 0.36165015399456024) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -3.1025575399398804) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8434191346168518) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.33148643374443054) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5400580763816833) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.4613364189863205) { - if (averageDuration_2 <= -0.5624776482582092) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5705105066299438) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6971102356910706) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.452039897441864) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 7.269208669662476) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.985676348209381) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9450717270374298) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4659591317176819) { - if (averageDuration_2 <= -0.6260405778884888) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.1279932260513306) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.263444185256958) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9643280804157257) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.0422221422195435) { - if (averageDuration_2 <= -0.7380890250205994) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.2544466033577919) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.629876583814621) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.6267067193984985) { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.048900008201599) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.6689746677875519) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.130414366722107) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.557671844959259) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.17258320748806) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { - if (maxDuration_2 <= 0.25258977711200714) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.2148807048797607) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.611809015274048) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5296339988708496) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.23457122594118118) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.292544662952423) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 0.998237282037735) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.11693140491843224) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.3092772364616394) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - if (averageDuration_2 <= -0.2714572548866272) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7607354819774628) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5340162217617035) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.075546741485596) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.4010125398635864) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.1280596256256104) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.679324150085449) { - if (cpuCoreIdleTimesPercentage_6_2 <= -4.446711540222168) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.5062246322631836) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.9133753776550293) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.05649562552571297) { - if (maxDuration_2 <= 0.8136114478111267) { - if (maxDuration_2 <= 0.07544586062431335) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5781428217887878) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.075348138809204) { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.2259503602981567) { - if (maxDuration_2 <= 0.19446707516908646) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8818207383155823) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.32224899530410767) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.32002657651901245) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 2.1921916007995605) { - if (averageDuration_2 <= -0.3642892390489578) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 1.3434457182884216) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.242711365222931) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1290903091430664) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5747501850128174) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.4205806255340576) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1047318577766418) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - if (averageDuration_2 <= -0.2931518107652664) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461348295211792) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5136006474494934) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.71760094165802) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.21279997378587723) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.14037324488162994) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6354797780513763) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.2524218484759331) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1320648193359375) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (numDurations_2 <= 7.269208908081055) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.593853771686554) { - if (maxDuration_2 <= 0.05835269205272198) { - if (averageDuration_2 <= -0.19413460791110992) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 1.767752766609192) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5344536006450653) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= 0.09302541613578796) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.4075369834899902) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (maxDuration_2 <= 0.08447499200701714) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.1780346632003784) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7952302098274231) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.2288076281547546) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.575429320335388) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.223210871219635) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8546578884124756) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - if (maxDuration_2 <= 1.300899088382721) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.47516460716724396) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - if (averageDuration_2 <= -0.13573668897151947) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06185682862997055) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1074347235262394) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (averageDuration_2 <= -0.10972913727164268) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - if (averageDuration_2 <= -0.1314106062054634) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.161266565322876) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0673220781609416) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= 0.2927685081958771) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.16774874180555344) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.003833495080471039) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= 0.47503624856472015) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8772368133068085) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.272525817155838) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620584785938263) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.14366307854652405) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1166411638259888) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5400350093841553) { - if (maxDuration_2 <= 0.5393617451190948) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.05858609080314636) { - if (averageDuration_2 <= -0.38487212359905243) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.21749939769506454) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (averageDuration_2 <= -0.16139937937259674) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.225828155875206) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.24401267617940903) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.712962806224823) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.027522695250809193) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1084095872938633) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.10518838092684746) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6922973990440369) { - if (averageDuration_2 <= -0.6417401134967804) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4900496304035187) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - if (maxDuration_2 <= 0.0650872066617012) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.11292750015854836) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.016777722164988518) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5211844444274902) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5151720345020294) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.5771467983722687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.2386099100112915) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7585369348526) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.3994940221309662) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= 1.7950525283813477) { - if (maxDuration_2 <= 1.2090941071510315) { - if (averageDuration_2 <= -0.4267774075269699) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12311100959777832) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.730594277381897) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.4565378576517105) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.35311898589134216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.18880262970924377) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.32594868540763855) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1161888241767883) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (maxDuration_2 <= 2.19901442527771) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.18798432499170303) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768269538879) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9328323006629944) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.5486069321632385) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.47346721589565277) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0946219563484192) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= 1.270185112953186) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.0005955866508884355) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.24561848491430283) { - if (averageDuration_2 <= -0.5162278413772583) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.7564848363399506) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8963220119476318) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { - if (maxDuration_2 <= 0.20683931559324265) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 5.331565856933594) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.6132869720458984) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.528399646282196) { - if (maxDuration_2 <= 0.01901995821390301) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (maxDuration_2 <= 1.9041330814361572) { - if (numMissedDeadlines_2 <= 0.4979674816131592) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.160470485687256) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.781947135925293) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.5280866622924805) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.32349660992622375) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.2265063524246216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.688767433166504) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.9139808416366577) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (maxDuration_2 <= 1.8225526809692383) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.48887011408805847) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (averageDuration_2 <= -0.5238467454910278) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 1.1538560390472412) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4319878220558167) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.04870597831904888) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.40524159371852875) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.23347392678260803) { - if (maxDuration_2 <= 0.16828172653913498) { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.0709069967269897) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= -0.6811453700065613) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.37002432346344) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.25149397924542427) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.2049425840377808) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.178336024284363) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6945921778678894) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5262112617492676) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.3677852749824524) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 1.9398770928382874) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.541572332382202) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1309216022491455) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (averageDuration_2 <= -0.20028476417064667) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.06630406528711319) { - if (maxDuration_2 <= 0.7696770429611206) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354038119316) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6678047180175781) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.3303449749946594) { - if (averageDuration_2 <= -0.4520481824874878) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.057918906211853) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5003063678741455) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.467879831790924) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.3558892011642456) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.02710987627506256) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 7.006031513214111) { - if (maxDuration_2 <= -0.022688363678753376) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6004821956157684) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.44367632269859314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.137228362262249) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (maxDuration_2 <= 0.07718826085329056) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0435512401163578) { - if (maxDuration_2 <= 0.0168038927949965) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.5833417177200317) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.21282974630594254) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.30125442147254944) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.2234894186258316) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6182535290718079) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.234639286994934) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9937716126441956) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7819706797599792) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4802909195423126) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.07018454559147358) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (maxDuration_2 <= 2.1677989959716797) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.093476414680481) { - if (averageDuration_2 <= -0.15875250101089478) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= 2.0851775407791138) { - if (maxDuration_2 <= 0.556437075138092) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11400765925645828) { - if (averageDuration_2 <= -0.751485139131546) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1327787134796381) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.26143111288547516) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.1711733117699623) { - if (maxDuration_2 <= 0.35787642002105713) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1602819338440895) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.5225780308246613) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7489333748817444) { - if (numMissedDeadlines_2 <= 0.4979674816131592) { - if (averageDuration_2 <= -0.6513746380805969) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7145256400108337) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (maxDuration_2 <= 0.17671563476324081) { - if (averageDuration_2 <= -0.5941755175590515) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5091793835163116) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0107775926589966) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.11968792229890823) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.06470723077654839) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6035351753234863) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.8111996948719025) { - if (averageDuration_2 <= -0.6481379568576813) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.2756536677479744) { - if (numMissedDeadlines_2 <= 0.4979674816131592) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2778780609369278) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.11040906235575676) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= 0.2224939912557602) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.7093262076377869) { - if (averageDuration_2 <= -0.509844034910202) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.023589939810335636) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.13456559926271439) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= -0.46671725809574127) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.5068370401859283) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.050092317163944244) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (maxDuration_2 <= 0.1294529102742672) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5201620161533356) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15095919370651245) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6912243962287903) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.43619488179683685) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6963398456573486) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.4464073181152344) { - if (averageDuration_2 <= -0.5285005867481232) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8296833634376526) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.677399069070816) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.06424967106431723) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= -0.37228943407535553) { - if (maxDuration_2 <= 0.2286256104707718) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8462361097335815) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.09048087149858475) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.5836156010627747) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9859866499900818) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= 0.09572261571884155) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4882946312427521) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - if (maxDuration_2 <= 0.09548944979906082) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5141507685184479) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239523053169) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1838994361460209) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.5279933512210846) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6262762546539307) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= -0.548039585351944) { - if (averageDuration_2 <= -0.7452587187290192) { - if (maxDuration_2 <= 0.007058119750581682) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.34765157103538513) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0059900283813477) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9712731540203094) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3935430347919464) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.272525817155838) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.5807764828205109) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.048056721687317) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8319652080535889) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3836115002632141) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.5761618912220001) { - if (maxDuration_2 <= 0.1911594271659851) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0131391882896423) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.18659298866987228) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2168656587600708) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.3723158538341522) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.5579911172389984) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239523053169) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6055815815925598) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (averageDuration_2 <= -0.4701688140630722) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7472152709960938) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9628521203994751) { - if (averageDuration_2 <= -0.5022730529308319) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.32370586693286896) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0022448897361755) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= -0.7652776539325714) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9538859724998474) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= 0.4351133704185486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= 1.8275877237319946) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2397010400891304) { - if (averageDuration_2 <= -0.28144870698451996) { - if (maxDuration_2 <= 0.7009372115135193) { - if (averageDuration_2 <= -0.43845193088054657) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= 3.8542970418930054) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0913238525390625) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18284162878990173) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17884714156389236) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1800810545682907) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.02574416622519493) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (averageDuration_2 <= -0.3558998256921768) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8892287611961365) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5475223958492279) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0295605659484863) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6150467693805695) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.10960160568356514) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3855178654193878) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 1.2984701991081238) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.3449589014053345) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.719704806804657) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.22398759424686432) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.2498842179775238) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8681597113609314) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.015031187795102596) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.070236921310425) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0673220781609416) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0260080099105835) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.5091347396373749) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.49085164070129395) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - if (cpuCoreIdleTimesPercentage_7_2 <= 1.1482599973678589) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9398877024650574) { - if (maxDuration_2 <= 3.6411495208740234) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7452818751335144) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.7475045919418335) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.18802716583013535) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 12.67615270614624) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5397311449050903) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= 3.0530433654785156) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8585796356201172) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.17847102135419846) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7548507452011108) { - if (maxDuration_2 <= 2.378470778465271) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.921450436115265) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.11248239129781723) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.10004199296236038) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.49423402547836304) { - if (maxDuration_2 <= 2.307945489883423) { - if (averageDuration_2 <= -0.3815537840127945) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1408124752342701) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 2.119275212287903) { - if (averageDuration_2 <= -0.42956797778606415) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= 4.4696619510650635) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0048209726810455) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.48976415395736694) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.56740602850914) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5773622393608093) { - if (maxDuration_2 <= 5.429134130477905) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.49154479801654816) { - if (maxDuration_2 <= 0.22083500027656555) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4614723324775696) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9802378714084625) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.35311898589134216) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.778552919626236) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.2055400386452675) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794910855591297) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.3128224015235901) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.4354717582464218) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07156907208263874) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (numDurations_2 <= 3.8542970418930054) { - if (maxDuration_2 <= 0.02867724746465683) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.54273784160614) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.5149007141590118) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4545262455940247) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 4.677119731903076) { - if (averageDuration_2 <= -0.6398843228816986) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3323505520820618) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3076878786087036) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.37819714844226837) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.845037192106247) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.24997970461845398) { - if (numDurations_2 <= 3.8542970418930054) { - if (averageDuration_2 <= -0.5004489421844482) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4318339824676514) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.45547595620155334) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.47703440487384796) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.3323989361524582) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - if (maxDuration_2 <= 0.2060997560620308) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.34444981813430786) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8611432313919067) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6814408600330353) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4521138668060303) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - if (maxDuration_2 <= 0.38989217579364777) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.41172653436660767) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.25149397924542427) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8814854323863983) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.018933151848614216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= 4.436450004577637) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3990305662155151) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.361455500125885) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.09119118750095367) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.43390679359436035) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 1.5302519798278809) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3929396867752075) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7736648917198181) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.1783012747764587) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } - } else { - if (maxDuration_2 <= 2.9522114992141724) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.6982106566429138) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7311728298664093) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.4576098918914795) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0462589859962463) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5585419535636902) { - if (averageDuration_2 <= 0.1486605927348137) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.3800418376922607) { - if (averageDuration_2 <= 0.09054486453533173) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.118008613586426) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.6331998109817505) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.7575366497039795) { - if (averageDuration_2 <= 1.4525668621063232) { - if (maxDuration_2 <= 1.8205693364143372) { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.504787921905518) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.850463032722473) { - if (averageDuration_2 <= 1.3933514952659607) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.2126322984695435) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.6992023289203644) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.7221550345420837) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.4106956720352173) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0437865257263184) { - if (maxDuration_2 <= 0.2709393948316574) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.21510637551546097) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.1971208155155182) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.599726915359497) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541474819183) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.375064417719841) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 2.1763941049575806) { - if (cpuCoreIdleTimesPercentage_7_2 <= -4.470188617706299) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.883186459541321) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.8774354457855225) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.7221550345420837) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.6144105195999146) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.622730255126953) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.0976390838623047) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= 2.0659995079040527) { - if (averageDuration_2 <= 1.290369689464569) { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.0709069967269897) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.7397610545158386) { - if (averageDuration_2 <= 0.8549333810806274) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.34606271982192993) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7403286695480347) { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 1.821423590183258) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.404924750328064) { - if (maxDuration_2 <= 0.6772339046001434) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= 2.4786592721939087) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.117706298828125) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.2537388801574707) { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.405732154846191) { - if (numDurations_2 <= 0.7239612340927124) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.304485559463501) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.495772123336792) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.04143369011580944) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2884135246276855) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.4520399570465088) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3127472847700119) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.60867977142334) { - if (numDurations_2 <= 1.5776892304420471) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.8958566188812256) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.14996526390314102) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.808729112148285) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.6988641023635864) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= -0.12976674735546112) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.726457417011261) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.1272987127304077) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - if (numDurations_2 <= -0.12976674735546112) { - if (maxDuration_2 <= 1.5962337255477905) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.7316962480545044) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.1413493156433105) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.013322114944458) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.33028675615787506) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.734416902065277) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.863446444272995) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6294126510620117) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6758462190628052) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.075559675693512) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= -0.05943634361028671) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.9026169776916504) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - if (maxDuration_2 <= 0.7086468935012817) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3543576002120972) { - if (averageDuration_2 <= 0.29496756196022034) { - if (averageDuration_2 <= 0.16842085123062134) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.08231697604060173) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3452712893486023) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.271478071808815) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.5101791620254517) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.8452296257019043) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5434206128120422) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.459313303232193) { - if (numMissedDeadlines_2 <= 0.4979674816131592) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.54273784160614) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.42461895942688) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.2490766644477844) { - if (averageDuration_2 <= 0.22652053087949753) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.9596757292747498) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6429605782032013) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4608699083328247) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7126609981060028) { - if (maxDuration_2 <= 0.6500527560710907) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.350590229034424) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.4920990765094757) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.0642496682703495) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6805217266082764) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.2831013202667236) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.4812127351760864) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.8774354457855225) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.432702660560608) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3006606101989746) { - if (averageDuration_2 <= 0.10798526182770729) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.984292209148407) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 1.354845404624939) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.26259645819664) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6721392571926117) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.542516827583313) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (maxDuration_2 <= 2.51642906665802) { - if (averageDuration_2 <= 0.7064923346042633) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.05273069394752383) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.294482946395874) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 1.5332456827163696) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.6031864881515503) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (maxDuration_2 <= 0.7267680764198303) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.8356302082538605) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.6962794363498688) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.5074199438095093) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0358821153640747) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.24824069440364838) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.2925446033477783) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6422990262508392) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0462589859962463) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.32935941219329834) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.502444714307785) { - if (maxDuration_2 <= 0.8869432508945465) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 0.5068024098873138) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8702456951141357) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.013878376223146915) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1976703181862831) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.134287178516388) { - if (averageDuration_2 <= 0.04693296737968922) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.04728369414806366) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= 2.4848499298095703) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8753038048744202) { - if (maxDuration_2 <= 0.6186196208000183) { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.260116338729858) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.160470485687256) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0110052227973938) { - if (averageDuration_2 <= 0.4915490001440048) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.24874429404735565) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.2788926362991333) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.8173737525939941) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.8602667450904846) { - if (numDurations_2 <= -1.837222695350647) { - if (maxDuration_2 <= 0.28434236347675323) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.442385733127594) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.930047035217285) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.631614089012146) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.6582285463809967) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.273658275604248) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2071656584739685) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 4.469818353652954) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - if (cpuCoreIdleTimesPercentage_6_2 <= -4.531028747558594) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5517327040433884) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3323505520820618) { - if (numDurations_2 <= -1.837222695350647) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8020380735397339) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -4.637903451919556) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.486834526062012) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.522068202495575) { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.0095096826553345) { - if (averageDuration_2 <= 1.1721805334091187) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.830192446708679) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.9290050268173218) { - if (cpuCoreIdleTimesPercentage_5_2 <= -5.132140636444092) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1497039794921875) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.055688202381134) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.554762065410614) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.4071969985961914) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.11133947968482971) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= -1.837222695350647) { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.1149210929870605) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.800664186477661) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.6528968811035156) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.7993290424346924) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.2214198112487793) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.9968165159225464) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.5192242860794067) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= 0.3964579850435257) { - if (averageDuration_2 <= -0.08234961330890656) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0978952050209045) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8546172976493835) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.390951991081238) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 0.08504298329353333) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7010758519172668) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8798046708106995) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.6698808670043945) { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.454002380371094) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -3.1456851959228516) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= 0.385555163025856) { - if (averageDuration_2 <= 0.20968328416347504) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 0.2824081927537918) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.18522001057863235) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.625324845314026) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.4125157594680786) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.952915906906128) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4070816785097122) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 0.35368120670318604) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.09199321269989) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4598904252052307) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.024251937866211) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.19566070288419724) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= 0.30949611961841583) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.136139154434204) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.16410893201828) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.005236268043518) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.6793462634086609) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.7187942266464233) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.460745394229889) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616687893867493) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.319916009902954) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.599594235420227) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.048766613006592) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.1213459968566895) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.6415618658065796) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.5058279037475586) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.994012176990509) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - if (averageDuration_2 <= 0.5401733815670013) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.117706298828125) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.182707667350769) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4611977934837341) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9030492603778839) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461599349975586) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 4.330597400665283) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0260956287384033) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5377739667892456) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.1025969982147217) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4375660419464111) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9893044829368591) { - if (maxDuration_2 <= 0.28874412178993225) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.345078229904175) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8317449688911438) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.1009268760681152) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.6988641023635864) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.2400052547454834) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.7180163860321045) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.34257173538208) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 4.240623712539673) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8261885643005371) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 4.211121559143066) { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.207621097564697) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.1025969982147217) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.1618149280548096) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= -0.02070558536797762) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.8774354457855225) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.9925618767738342) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 4.170281648635864) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.960754632949829) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.60867977142334) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.7453612089157104) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2293047308921814) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.2559274435043335) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= 0.7730573415756226) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numMissedDeadlines_2 <= 0.4979674816131592) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1326106786727905) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.647126168012619) { - if (maxDuration_2 <= 0.8377886414527893) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3478758335113525) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.38911469280719757) { - if (maxDuration_2 <= 0.8200269639492035) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.9040391147136688) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= 2.1897956132888794) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.6550031900405884) { - if (averageDuration_2 <= 2.0180875062942505) { - if (numMissedDeadlines_2 <= 4.563007950782776) { - if (averageDuration_2 <= -0.04849856346845627) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 1.288592517375946) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.8727827072143555) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.625324845314026) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= 2.1797780990600586) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (numDurations_2 <= -0.12976674735546112) { - if (averageDuration_2 <= 0.08269862830638885) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numMissedDeadlines_2 <= 4.563007950782776) { - if (maxDuration_2 <= 0.8466176688671112) { - if (numDurations_2 <= -1.837222695350647) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.718425154685974) { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.2029491662979126) { - if (maxDuration_2 <= 0.7737343907356262) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8489216864109039) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8015914261341095) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.7930396795272827) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3338761925697327) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.6955958604812622) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.9345415830612183) { - if (maxDuration_2 <= 0.7773562371730804) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9898547530174255) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.442385733127594) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= 0.4682307243347168) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { - if (averageDuration_2 <= 1.189909279346466) { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.226507544517517) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.6782695353031158) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.8109508752822876) { - if (numDurations_2 <= -1.837222695350647) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.304485559463501) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.9236379861831665) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 1.7793945670127869) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.808453768491745) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8431202173233032) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.1272987127304077) { - if (maxDuration_2 <= 1.098124086856842) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.851856768131256) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2898950576782227) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0922346115112305) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8827711343765259) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4990555047988892) { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9364900290966034) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.2291572466492653) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.951200842857361) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 1.543505609035492) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.582572817802429) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616853594779968) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 2.2258235216140747) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.8385125398635864) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.0461134016513824) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.876897096633911) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.331530213356018) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0809954404830933) { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.075546741485596) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3106040358543396) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6401868760585785) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.134287178516388) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8041815161705017) { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuCoreIdleTimesPercentage_7_2 <= -4.218616247177124) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.604988932609558) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 1.8012365698814392) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.8564924001693726) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.06201171875) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - if (cpuCoreIdleTimesPercentage_6_2 <= -4.531028747558594) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 1.5776891708374023) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.5477566719055176) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.396687924861908) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8302848935127258) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4991838932037354) { - if (maxDuration_2 <= 1.411458671092987) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1459314823150635) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.1186873316764832) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.10788631439209) { - if (averageDuration_2 <= 1.667149305343628) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6797280311584473) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.3800418376922607) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.6035412549972534) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.851856768131256) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.679324150085449) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.857966423034668) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -5.289881944656372) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.2831013202667236) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.9797444343566895) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.722473919391632) { - if (maxDuration_2 <= 1.8076249361038208) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.4803755283355713) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8675131797790527) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9170226454734802) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.6415618658065796) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.370543122291565) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.4852719902992249) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8481956124305725) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.905318558216095) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.4812127351760864) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.808729112148285) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.83640456199646) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7590811252593994) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.366545557975769) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -6.090893983840942) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (maxDuration_2 <= 1.6119794845581055) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 4.350725889205933) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.068911075592041) { - if (numDurations_2 <= -1.837222695350647) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.084824323654175) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.1884634494781494) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.292544722557068) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.319916009902954) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3047654926776886) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.405732154846191) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3218483328819275) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.702006757259369) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.2170642614364624) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 0.5376117378473282) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4133901596069336) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6102865934371948) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3418726325035095) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.0849900245666504) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 1.6949339509010315) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.176781415939331) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { - if (cpuCoreIdleTimesPercentage_6_2 <= -4.446711778640747) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.662456214427948) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.641247868537903) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3935690522193909) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7028929591178894) { - if (averageDuration_2 <= 2.041002631187439) { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.1149210929870605) { - if (averageDuration_2 <= 1.633895456790924) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.844688057899475) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.3491384983062744) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9994883835315704) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= 0.9023451507091522) { - if (numDurations_2 <= 1.008537232875824) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.013322114944458) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.188086748123169) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -5.224905490875244) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.498723864555359) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.751004695892334) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9736347496509552) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.655320167541504) { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.471769332885742) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.2294156551361084) { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.6698808670043945) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.6146548986434937) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.2547974586486816) { - if (numMissedDeadlines_2 <= 4.563007950782776) { - if (cpuCoreIdleTimesPercentage_7_2 <= -5.141047954559326) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 0.43938523530960083) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4283981323242188) { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.631614089012146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4851100444793701) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.781385064125061) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 1.52111154794693) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= 1.77457195520401) { - if (maxDuration_2 <= 1.265385627746582) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6666991114616394) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 1.4920134544372559) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.488429546356201) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.1459453105926514) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 2.2893961668014526) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= 0.221854530274868) { - if (cpuCoreIdleTimesPercentage_7_2 <= -4.470188617706299) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.45564341545105) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.3666815757751465) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -4.531028747558594) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.091283082962036) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.345078229904175) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (maxDuration_2 <= 1.9867419600486755) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.597325921058655) { - if (averageDuration_2 <= 2.0434041023254395) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.9670439958572388) { - if (averageDuration_2 <= 1.0895439982414246) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 5.202355623245239) { - if (maxDuration_2 <= 0.8233751654624939) { - if (averageDuration_2 <= 1.2072237133979797) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.2961843013763428) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.9852243959903717) { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.239214777946472) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.1885876655578613) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.655748724937439) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.6550031900405884) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.5052746534347534) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.1783012747764587) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= 0.46462877094745636) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.428841769695282) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.844688057899475) { - if (numDurations_2 <= -0.4143427312374115) { - if (maxDuration_2 <= 0.24061018973588943) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 0.1447945162653923) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.399016797542572) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9464494585990906) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.1127390265464783) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - if (maxDuration_2 <= 2.834039092063904) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613980650901794) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.4009926319122314) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4252933859825134) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4600907564163208) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 0.7907878756523132) { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.10518838092684746) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3357419818639755) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.0572614073753357) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9362237751483917) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8813528418540955) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -5.289881944656372) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.835106372833252) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.803012490272522) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.151027202606201) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.149576187133789) { - if (numMissedDeadlines_2 <= 4.563007950782776) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0022448897361755) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.239214777946472) { - if (averageDuration_2 <= 2.5127698183059692) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.9265406727790833) { - if (averageDuration_2 <= 2.7541388273239136) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= 3.13879930973053) { - if (cpuCoreIdleTimesPercentage_4_2 <= -4.027185082435608) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.1600269079208374) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.960754632949829) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 1.7837414741516113) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 2.542690634727478) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6604793667793274) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.014568865299225) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.0507539510726929) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.6338953971862793) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.801955223083496) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.490656018257141) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0869851112365723) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.5236746072769165) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= -1.837222695350647) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0119067430496216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.10788631439209) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 4.961464166641235) { - if (cpuCoreIdleTimesPercentage_5_2 <= -4.0095096826553345) { - if (averageDuration_2 <= 2.5150275230407715) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8963220119476318) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.8748806715011597) { - if (maxDuration_2 <= 1.7359243035316467) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3055525422096252) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { - if (averageDuration_2 <= 0.5719016194343567) { - if (numDurations_2 <= -0.6989187151193619) { - if (averageDuration_2 <= 0.07649639993906021) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0462589859962463) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { - if (maxDuration_2 <= 0.2240009680390358) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.26107440888881683) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.0902730822563171) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.4010435938835144) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3378981351852417) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6615205407142639) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 0.06037459522485733) { - if (averageDuration_2 <= 0.02208957076072693) { - if (maxDuration_2 <= 0.30896005034446716) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.2961843013763428) { - if (averageDuration_2 <= 0.24445046484470367) { - if (maxDuration_2 <= 0.32748159766197205) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.29349569976329803) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.04988821968436241) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.28652288764715195) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.5293399691581726) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (maxDuration_2 <= 0.38118231296539307) { - if (averageDuration_2 <= 0.4230045974254608) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.9649280905723572) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4184390902519226) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5553891062736511) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8387055993080139) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.3291455805301666) { - if (averageDuration_2 <= 0.2996497303247452) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.3572763353586197) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.062345417216420174) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4740549325942993) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3713284134864807) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 0.41237059235572815) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.018933151848614216) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 0.5424788296222687) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.7656015157699585) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040612459183) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6945921778678894) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7381604015827179) { - if (maxDuration_2 <= 1.1129506826400757) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.350590229034424) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4067111909389496) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.6184421181678772) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7311698794364929) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= 0.351149246096611) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - if (averageDuration_2 <= 0.12465944513678551) { - if (maxDuration_2 <= 0.7832927405834198) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.5976099371910095) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6686082780361176) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.470812126994133) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.7511109113693237) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= 0.01048527006059885) { - if (maxDuration_2 <= 0.2389868199825287) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7504059076309204) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.128469467163086) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7483816742897034) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.6035412549972534) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.1678913831710815) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.134857416152954) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.43490731716156) { - if (maxDuration_2 <= 0.1703026443719864) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7448217272758484) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.203004002571106) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.8437918424606323) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 0.18470660597085953) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6791254580020905) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.950354814529419) { - if (averageDuration_2 <= 0.7556245028972626) { - if (maxDuration_2 <= 0.42229805886745453) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.48527152836322784) { - if (averageDuration_2 <= 0.5910443365573883) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.5414674282073975) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3966309577226639) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.04611337184906) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.319189190864563) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.12226511165499687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.07891198061406612) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9396538734436035) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - if (maxDuration_2 <= 1.2051023840904236) { - if (maxDuration_2 <= 0.44002945721149445) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.091744314879179) { - if (averageDuration_2 <= 0.8598925769329071) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.349451407790184) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.43471239507198334) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.724583625793457) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7416684925556183) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6342105865478516) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= 1.3143450617790222) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.49390411376953125) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8384836912155151) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9582308232784271) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.19088488817214966) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.0145689249038696) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9062472879886627) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.9390407502651215) { - if (maxDuration_2 <= 0.4803650379180908) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (averageDuration_2 <= -0.07482349872589111) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5795984268188477) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3655945956707001) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.9084832668304443) { - if (averageDuration_2 <= 0.0012164053623564541) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.09357177093625069) { - if (maxDuration_2 <= 1.3117946982383728) { - if (maxDuration_2 <= 0.1487571969628334) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5140326619148254) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.905464768409729) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.001517653465271) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.29803667962551117) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8714234828948975) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6181853413581848) { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 0.777886837720871) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.3181776702404022) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.02969856234267354) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5322262048721313) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5424161851406097) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.19072522222995758) { - if (averageDuration_2 <= 0.6368220150470734) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.32581014931201935) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.6577824354171753) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 1.008537232875824) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9306732416152954) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.27020205557346344) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.3255345225334167) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (numMissedDeadlines_2 <= 0.4979674816131592) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.36921536922454834) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.49233707785606384) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4125160872936249) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5693084299564362) { - if (maxDuration_2 <= 1.0592498183250427) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.14956074953079224) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.3192725330591202) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.4149769991636276) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1329648569226265) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.41851629316806793) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.41889698803424835) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991199404001) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5143053233623505) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.33432537317276) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.6966274082660675) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5344177782535553) { - if (averageDuration_2 <= 2.523739218711853) { - if (averageDuration_2 <= 1.5712027549743652) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.8996076881885529) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.14654291793704033) { - if (averageDuration_2 <= 2.4023046493530273) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7965860366821289) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= -0.017729665152728558) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (numDurations_2 <= 3.2851450443267822) { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.960754632949829) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.2370796948671341) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.91253662109375) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4284600615501404) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7041893005371094) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.0446120500564575) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.37746837735176086) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.4010435938835144) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.4519153833389282) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.115258574485779) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.533225178718567) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.08479142934083939) { - if (averageDuration_2 <= -0.05249614082276821) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1320134960114956) { - if (maxDuration_2 <= 0.028340275399386883) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.79072505235672) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= 0.051359884440898895) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1289394274353981) { - if (maxDuration_2 <= 0.8915399610996246) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.37297840416431427) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.995977759361267) { - if (maxDuration_2 <= 0.21579502522945404) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.45206883549690247) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.5143053084611893) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.3828223645687103) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.22742345184087753) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.3584911823272705) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.33819037675857544) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= 0.11382882669568062) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.040633410215378) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9848006963729858) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.02166930353268981) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.8380184173583984) { - if (maxDuration_2 <= 0.004692597081884742) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.4484702348709106) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (averageDuration_2 <= -0.07942678034305573) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.42254483699798584) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6678047180175781) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3323505520820618) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6226781606674194) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.271142840385437) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.36921538412570953) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.009295566007494926) { - if (averageDuration_2 <= -0.01869127992540598) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.35231979191303253) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4931092709302902) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (maxDuration_2 <= 0.34423041343688965) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0108182430267334) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3071543276309967) { - if (maxDuration_2 <= 1.0780044794082642) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.970194160938263) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.25149397924542427) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.26054825633764267) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.2469632625579834) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (maxDuration_2 <= 1.5519875884056091) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 1.0289577841758728) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.5477566719055176) { - if (averageDuration_2 <= 0.2389715388417244) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.116235136985779) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3895057439804077) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.677799701690674) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.41473303735256195) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.8431501388549805) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.8602667450904846) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5900271534919739) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.10434138402342796) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7321376204490662) { - if (averageDuration_2 <= 0.6705574095249176) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.568812906742096) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 1.57365220785141) { - if (numDurations_2 <= 3.2851450443267822) { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.5744280219078064) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4451440572738647) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.744037687778473) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.009311020374298) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.38823847472667694) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6198905408382416) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.6051508486270905) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.49333690106868744) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.01007906161248684) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (maxDuration_2 <= 0.11691359803080559) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.616599202156067) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.3423902541399002) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9804890751838684) { - if (maxDuration_2 <= 0.20280230790376663) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.465425193309784) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.19301842898130417) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.40805475413799286) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0432409048080444) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.0055207312107086) { - if (maxDuration_2 <= 0.7784756720066071) { - if (averageDuration_2 <= 0.00045019247045274824) { - if (numDurations_2 <= 2.1468411684036255) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.8702026605606079) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.2911977767944336) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.868710458278656) { - if (maxDuration_2 <= 0.5014396905899048) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5386690497398376) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.014568865299225) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5480102896690369) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5141507685184479) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.2385960817337036) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= 0.5803462862968445) { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.3800418376922607) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.9437862634658813) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5405186712741852) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5388980507850647) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5335530638694763) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9553164541721344) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9171308279037476) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= 0.1604827642440796) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8406128585338593) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.29801954329013824) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4208534359931946) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.43234983086586) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.11082524061203) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.140161156654358) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.9565199613571167) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8299274742603302) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.2123268842697144) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -3.128469467163086) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.338785767555237) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.6362186670303345) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.403375267982483) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.7640702724456787) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (numDurations_2 <= -1.837222695350647) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (maxDuration_2 <= 0.7639706134796143) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.4470726549625397) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.6281538009643555) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.3796340823173523) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6138985455036163) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7035243213176727) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5435339510440826) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2256015539169312) { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.08362457156181335) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4112984538078308) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575631141663) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.599594235420227) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { - if (numDurations_2 <= 2.1468411684036255) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.563613772392273) { - if (averageDuration_2 <= 0.19177384674549103) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6711389422416687) { - if (averageDuration_2 <= 0.7540326118469238) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.0572593212127686) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6180667579174042) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.49911367893219) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.7909364998340607) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.9649280905723572) { - if (averageDuration_2 <= 0.2766471654176712) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5798149406909943) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4291403889656067) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0604326725006104) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.6642495393753052) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.18441375344991684) { - return ThrottleDecision::THROTTLE_70; - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6570369601249695) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.319189190864563) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.076667070388794) { - if (averageDuration_2 <= 0.5933231711387634) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.45581473410129547) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5548446774482727) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.3226674795150757) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.034745775163173676) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0761001892387867) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= -0.013819535728543997) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.47407588362693787) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7952302098274231) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 1.469601571559906) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6936079263687134) { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0457582687959075) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.36150892078876495) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.5304139256477356) { - if (averageDuration_2 <= 0.11544063314795494) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.5469828546047211) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0121926069259644) { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.0727112777531147) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.01059802109375596) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6442835628986359) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.8087291717529297) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.9495785534381866) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (maxDuration_2 <= 0.15957676619291306) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0551278591156006) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.20999136567115784) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.16597727686166763) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= 0.09759169071912766) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15939360857009888) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.5590015649795532) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.7289727926254272) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2373237609863281) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4379800409078598) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4877425730228424) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - if (averageDuration_2 <= 0.05946826748549938) { - if (maxDuration_2 <= 0.5331488847732544) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= 0.01603667251765728) { - if (averageDuration_2 <= 0.013127036858350039) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.6587780117988586) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.6793462634086609) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7630694508552551) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5822621583938599) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.036575973033905) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.2359508872032166) { - if (numMissedDeadlines_2 <= 0.4979674816131592) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0765175819396973) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7394643425941467) { - if (maxDuration_2 <= 0.7627500891685486) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.466018319129944) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.027762568555772305) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777280002832) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 1.4731804728507996) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.06222588289529085) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.6281538009643555) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8408084511756897) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= 1.8594541549682617) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.34999026358127594) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6874111592769623) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.5621040463447571) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4964073896408081) { - if (numDurations_2 <= -1.2680706679821014) { - if (averageDuration_2 <= 0.2305276244878769) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396327018738) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (maxDuration_2 <= 0.49224594235420227) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.432234525680542) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (averageDuration_2 <= 0.5220351219177246) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.13107352703809738) { - if (averageDuration_2 <= 0.3472038060426712) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8395796120166779) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.32139360904693604) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (averageDuration_2 <= 0.675759881734848) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0971235036849976) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (maxDuration_2 <= 0.9694303870201111) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.2693729996681213) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0708580613136292) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8715697526931763) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.25132977217435837) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.692672461271286) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.3746294379234314) { - if (maxDuration_2 <= 0.27050620317459106) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.5094808042049408) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9819397926330566) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.3154456466436386) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.31720077246427536) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.054093148559331894) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.7751853168010712) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9384127259254456) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.15529866516590118) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4067864269018173) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } else { - if (averageDuration_2 <= 0.2571268379688263) { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1699137687683105) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4049559831619263) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.0730167627334595) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - if (averageDuration_2 <= 0.1526781991124153) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.309035986661911) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4608147740364075) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6744439005851746) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= 0.15745744854211807) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.4184123277664185) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.115890920162201) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 0.4246281683444977) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.00414776802063) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - if (averageDuration_2 <= 0.17485319823026657) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9452307224273682) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5874207615852356) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.706470251083374) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.65778249502182) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.619035542011261) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.7213721871376038) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.8167940080165863) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8826395273208618) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.312984347343445) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= 2.7159931659698486) { - if (maxDuration_2 <= 0.8714329898357391) { - if (averageDuration_2 <= 0.058840448036789894) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.2660975456237793) { - if (numDurations_2 <= -0.12976674735546112) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.3211751878261566) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4400136470794678) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7145272493362427) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.175323273986578) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.10965907946228981) { - if (maxDuration_2 <= 0.3895578533411026) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.7562755346298218) { - if (averageDuration_2 <= 0.050177525728940964) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5755797326564789) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5181328058242798) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4156544655561447) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.1941758468747139) { - if (maxDuration_2 <= 0.026648390339687467) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1611754074692726) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.7670581638813019) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0340837240219116) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.7867504358291626) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= 0.20685764402151108) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.41522209346294403) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8970982432365417) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.13847704604268074) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 0.29203398525714874) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5556002855300903) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4452753067016602) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.4602272510528564) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.16949505358934402) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.3361035585403442) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1694764569401741) { - if (averageDuration_2 <= 0.06819140911102295) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.6698195934295654) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.938111960887909) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4612407684326172) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 1.3514944911003113) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9102553725242615) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6891494989395142) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numDurations_2 <= 3.8542970418930054) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.017462730407715) { - if (averageDuration_2 <= 0.1209564283490181) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.040496958419680595) { - if (maxDuration_2 <= 0.5668059587478638) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.3269814252853394) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.695732593536377) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= 0.14209871739149094) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8102989792823792) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.440079003572464) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= 0.0622138287872076) { - if (maxDuration_2 <= 0.22833936661481857) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619540572166443) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.1465429225936532) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (averageDuration_2 <= 0.0418302696198225) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7781811356544495) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.0053760707378387) { - if (maxDuration_2 <= 0.5117779970169067) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1103258728981018) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.242664396762848) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= -0.01706415507942438) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.062225885689258575) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.2951493263244629) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.050894604064524174) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= 0.629857212305069) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.18798432499170303) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6986220180988312) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.2120809406042099) { - if (maxDuration_2 <= 0.05979891121387482) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.17394530028104782) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (numMissedDeadlines_2 <= 0.4979674816131592) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.49415700137615204) { - if (averageDuration_2 <= 0.12261155247688293) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.024194462224841118) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= 0.08254513517022133) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.1529976911842823) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744680404663) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615398049354553) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.05594206787645817) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.46171373128891) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6922973990440369) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617088437080383) { - if (maxDuration_2 <= 0.5861581861972809) { - if (cpuCoreIdleTimesPercentage_2_2 <= -3.035153388977051) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= 0.9801110327243805) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.0378395318984985) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.40770813822746277) { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.0066321790218353) { - if (numDurations_2 <= -1.837222695350647) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.9915950894355774) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.1186873316764832) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4609662294387817) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.338785767555237) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.66507887840271) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.182704448699951) { - if (maxDuration_2 <= 0.7383172512054443) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.0976392030715942) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9409680068492889) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.5657902359962463) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.0867060422897339) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4553073644638062) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4615808129310608) { - if (maxDuration_2 <= 0.26559029519557953) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.33529411256313324) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3680250644683838) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.35603830218315125) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= 0.5403713285923004) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.7927008867263794) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4607444405555725) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (numDurations_2 <= -0.12976674735546112) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.698617547750473) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512211322784) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7305387854576111) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.13934404402971268) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.8643185794353485) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.17935702949762344) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7571576237678528) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.10640818625688553) { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 0.5010522305965424) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4206048846244812) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15307319909334183) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.6126470565795898) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.7358000874519348) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4604942798614502) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4604288339614868) { - if (averageDuration_2 <= 0.8754375278949738) { - if (averageDuration_2 <= 0.8354138433933258) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.411447286605835) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.831105351448059) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.7736910581588745) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9362237751483917) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.9516109228134155) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.4372236132621765) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.161177158355713) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7451625764369965) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8453426361083984) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.895442843437195) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7143044471740723) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1838470920920372) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.743975430727005) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7521025836467743) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.45386044681072235) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.11331991851329803) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9760718941688538) { - if (maxDuration_2 <= 0.0609410535544157) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.155582070350647) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.162376046180725) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9142167568206787) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.599594235420227) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.15058831125497818) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.981515049934387) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4286454766988754) { - if (maxDuration_2 <= 1.1187833547592163) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.625548005104065) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.7541018724441528) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 2.0860217809677124) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.627090334892273) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.36042580008506775) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5978890359401703) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.47598397731781) { - if (maxDuration_2 <= 1.5648765563964844) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3530983328819275) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.812830239534378) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.21876464039087296) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0160834789276123) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.3593592941761017) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.9291220307350159) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4594137072563171) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 2.5274583101272583) { - if (maxDuration_2 <= 0.6473707854747772) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.0760540664196014) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.3350065350532532) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.4484865665435791) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 1.2962273359298706) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473086357117) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.48443716764450073) { - if (averageDuration_2 <= 1.9543921947479248) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.473419725894928) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 2.684321403503418) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.40620583295822144) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.2528514862060547) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.5632896423339844) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.7121440172195435) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.4051479548215866) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.14397023990750313) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5266796350479126) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5847970843315125) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5370000600814819) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.50289386510849) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.47843292355537415) { - if (numDurations_2 <= -0.6989187151193619) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6495448648929596) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.756723016500473) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.6956399381160736) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.3489398956298828) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.2287803292274475) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5188332498073578) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.5775927007198334) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.9485477805137634) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.07451411336660385) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.5382480919361115) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 2.045895576477051) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9582308232784271) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.367463231086731) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.696106195449829) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 1.1645368933677673) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0472828010097146) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1055437326431274) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.8023326098918915) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.013568496098741889) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.0803013602271676) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.17178435623645782) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.2544687390327454) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.3096856027841568) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.4326643794775009) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (averageDuration_2 <= 1.4578538537025452) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.053328411653637886) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.15973930805921555) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.3782844841480255) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.03074631281197071) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.7399632930755615) { - if (averageDuration_2 <= 2.1465831995010376) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8287606239318848) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4503361582756042) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5649480819702148) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.30781756341457367) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9758623242378235) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9475547671318054) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.08503397554159164) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.45021992921829224) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.17073660716414452) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8293795585632324) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.8734205961227417) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.45773518085479736) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.046487331390381) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.7583185434341431) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.26091842353343964) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.2057830095291138) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.3045239597558975) { - if (averageDuration_2 <= 1.144224464893341) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9053962528705597) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.14249117905274034) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.31143125891685486) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.875568300485611) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 2.9560892581939697) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 3.7313427925109863) { - if (averageDuration_2 <= 3.054486393928528) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.48381105065345764) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.1753232777118683) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.1583473682403564) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.01704739686101675) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.162677824497223) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.5470512360334396) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9170674681663513) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8754225969314575) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1861354000866413) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.4761110693216324) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.6702903509140015) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.1387597918510437) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.091252326965332) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.3117746338248253) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06420721299946308) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= 0.022722860798239708) { - if (numDurations_2 <= 1.8622652292251587) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 2.264540195465088) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.22673305124044418) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0318717658519745) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8314541578292847) { - if (averageDuration_2 <= 0.040018025785684586) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.8115573525428772) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.023876428604125977) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.7359365224838257) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 3.012301206588745) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.08482426404953) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.9206715822219849) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.7821744978427887) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.5681280791759491) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (maxDuration_2 <= 1.8306444883346558) { - if (maxDuration_2 <= 1.822722315788269) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (averageDuration_2 <= 2.158921957015991) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.211506485939026) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.38604770600795746) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.072296380996704) { - if (averageDuration_2 <= -0.05623660609126091) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.6698195934295654) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 2.8249666690826416) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.43551841378211975) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4616902470588684) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.6202406883239746) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.1751411110162735) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6818858683109283) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.4757949411869049) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.963293582201004) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5377740263938904) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.3632214069366455) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6227197647094727) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.44503137469291687) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } else { - if (maxDuration_2 <= 1.254760980606079) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7751321494579315) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.8851237297058105) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.8210791945457458) { - if (averageDuration_2 <= -0.090853750705719) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.4340621829032898) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.24314958602190018) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7065825760364532) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.3004387617111206) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4613844156265259) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.13148777186870575) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.45699334144592285) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 0.23482564836740494) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.645479142665863) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.47463831305503845) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.687044084072113) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4617801308631897) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.12675218656659126) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.397545099258423) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3710131645202637) { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.27504225820302963) { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5811467468738556) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 0.6187161207199097) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2898950576782227) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774529695510864) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.783410906791687) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4006173610687256) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.461028814315796) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.0867060422897339) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.612310379743576) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.074470639228821) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.08888588473200798) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7703684866428375) { - if (averageDuration_2 <= 1.3027046918869019) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5661364197731018) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3587234020233154) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.027474880218506) { - if (averageDuration_2 <= 0.35692231357097626) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.01198148727417) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.018754313699901104) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7663010060787201) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5260390341281891) { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.0048857927322388) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.39077918231487274) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6991206109523773) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.4662815928459167) { - if (maxDuration_2 <= 1.4744365811347961) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (averageDuration_2 <= 0.5500186085700989) { - if (averageDuration_2 <= 0.5365014970302582) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 3.4690970182418823) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 1.4101492166519165) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.009798526763916) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.47222697734832764) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 3.086870312690735) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.7250277698040009) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (numDurations_2 <= -1.2680706679821014) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.08733349665999413) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.34203362464904785) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.2858968377113342) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { - if (averageDuration_2 <= 0.9354912638664246) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6008046567440033) { - if (maxDuration_2 <= 2.130601406097412) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.8508365154266357) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2060376405715942) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5708175152540207) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.399388611316681) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.2662731409072876) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.409091591835022) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6417961716651917) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.2913947105407715) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.729442596435547) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.1038766503334045) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.533344954252243) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 0.9473049342632294) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (averageDuration_2 <= 0.3951658606529236) { - if (numDurations_2 <= -0.6989187151193619) { - return ThrottleDecision::THROTTLE_70; - } else { - if (maxDuration_2 <= 1.4830199480056763) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9081359207630157) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.36880886554718) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.1965911984443665) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.4070816785097122) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.38558030128479) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9236922264099121) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= 0.6821088790893555) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7636559307575226) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.134287178516388) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6810545921325684) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -3.334991455078125) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 0.9183510541915894) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.0383227467536926) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.738096833229065) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.0858347415924072) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3962726593017578) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.760370969772339) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.1102917306125164) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2829664945602417) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9899911880493164) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 0.7443805634975433) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.9582308232784271) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.591736912727356) { - if (cpuCoreIdleTimesPercentage_4_2 <= -2.122923493385315) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.9797444343566895) { - if (maxDuration_2 <= 1.0872865915298462) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4375524520874023) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.9081359207630157) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6807795166969299) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.3103435635566711) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.5093331634998322) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 2.34213924407959) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.6550031900405884) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.5192242860794067) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.662302851676941) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.722473919391632) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9172006249427795) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.9165481925010681) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.625324845314026) { - if (numDurations_2 <= -1.2680706679821014) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.44350549578666687) { - if (maxDuration_2 <= 0.38587021827697754) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.2992626428604126) { - if (averageDuration_2 <= 3.0811301469802856) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.35207122564315796) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (maxDuration_2 <= 2.7767266035079956) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= 1.0188051462173462) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.1701518297195435) { - if (averageDuration_2 <= 0.45915351808071136) { - if (numDurations_2 <= 0.43938523530960083) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.0981072336435318) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.1513698473572731) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4619266986846924) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4526512622833252) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.140251100063324) { - if (numDurations_2 <= -0.6989187151193619) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4599754214286804) { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6862609386444092) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -3.0757460594177246) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.802748203277588) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (numDurations_2 <= 3.2851450443267822) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.3052783012390137) { - if (numDurations_2 <= 4.4234490394592285) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (maxDuration_2 <= 0.38272470235824585) { - if (maxDuration_2 <= 0.38140779733657837) { - if (averageDuration_2 <= 0.5128093361854553) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6829959154129028) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5132575482130051) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.9461768567562103) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.269288957118988) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= 4.255645513534546) { - if (maxDuration_2 <= 4.313700914382935) { - if (numMissedDeadlines_2 <= 2.5304877758026123) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.021501914598047733) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5938507318496704) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.7889090925455093) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.0324320793151855) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= 0.221229687333107) { - if (cpuCoreIdleTimesPercentage_6_2 <= 1.1603711545467377) { - if (maxDuration_2 <= 3.1527856588363647) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.49811258912086487) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5125864148139954) { - if (averageDuration_2 <= 1.1393049955368042) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.43777458369731903) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (maxDuration_2 <= 3.1482774019241333) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6341473162174225) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.1735256388783455) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.3594858050346375) { - if (maxDuration_2 <= 3.0874221324920654) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.6590568423271179) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.7736664116382599) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.31517699360847473) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.18648068606853485) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.23014948517084122) { - if (averageDuration_2 <= 2.2011454105377197) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.27485300600528717) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8165844082832336) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.24539414048194885) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.0740302801132202) { - if (cpuCoreIdleTimesPercentage_5_2 <= 1.1083666682243347) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6501322388648987) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.05064010247588158) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8294543623924255) { - if (cpuCoreIdleTimesPercentage_5_2 <= -3.6463054418563843) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.348728060722351) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.6061181426048279) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.6814691126346588) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.16553408652544022) { - if (averageDuration_2 <= 2.5150288343429565) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.2036247849464417) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.4092864990234375) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.5288888067007065) { - return ThrottleDecision::THROTTLE_70; - } else { - if (averageDuration_2 <= 1.3242594003677368) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (averageDuration_2 <= 0.7459826171398163) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.9593591690063477) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.6349726319313049) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.7930396795272827) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.3677852749824524) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.8989859223365784) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 3.342008113861084) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.5095426142215729) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= 1.8046969771385193) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.3908380270004272) { - if (maxDuration_2 <= 3.75872004032135) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.795726180076599) { - if (averageDuration_2 <= 0.13456124067306519) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.0572760105133057) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.1929267793893814) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.925930917263031) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 4.021517872810364) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.625324845314026) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 3.290730357170105) { - if (cpuCoreIdleTimesPercentage_4_2 <= -3.5018715858459473) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.1804072856903076) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (averageDuration_2 <= 2.957960844039917) { - if (cpuCoreIdleTimesPercentage_2_2 <= -2.6495232582092285) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (maxDuration_2 <= 3.4700006246566772) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.969179093837738) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= 0.1419707126915455) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.5036442279815674) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 3.34129798412323) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.9446317553520203) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (numMissedDeadlines_2 <= 4.563007950782776) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.04399488726630807) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } else { - if (numMissedDeadlines_2 <= 4.563007950782776) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3935797810554504) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.03771708160638809) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.33432537317276) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.6198905557394028) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6966036856174469) { - if (averageDuration_2 <= 0.8101759552955627) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - if (averageDuration_2 <= 1.3211275935173035) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= 5.565899610519409) { - if (averageDuration_2 <= 0.303888663649559) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= 0.022091149352490902) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.3421768546104431) { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.6130883395671844) { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.3774530291557312) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.2951493263244629) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.39236779510974884) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.47222697734832764) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.543883740901947) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.2883365154266357) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.736762136220932) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.6127462387084961) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= 4.846290826797485) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.839552640914917) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.6524451076984406) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.3907485604286194) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.9481760263442993) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.9961256682872772) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.56477789580822) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (maxDuration_2 <= 4.965301990509033) { - if (cpuCoreIdleTimesPercentage_4_2 <= -1.7946025133132935) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.7128522992134094) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.8075558245182037) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.5088971257209778) { - if (averageDuration_2 <= 1.1261682510375977) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.23199840635061264) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 4.810176849365234) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.781621515750885) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.567220538854599) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.12196319550275803) { - if (cpuCoreIdleTimesPercentage_3_2 <= -2.044527769088745) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -2.754804491996765) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.8976293802261353) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.40300142765045166) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.6064172685146332) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 3.712875247001648) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.09218606539070606) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.4135638624429703) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2182687297463417) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.06337766721844673) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= -0.163956917822361) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (maxDuration_2 <= 3.206650972366333) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.6542955935001373) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.23085995763540268) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.05081144720315933) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.4956154823303223) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.48101410269737244) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.1516360640525818) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.2741635739803314) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.057646654546260834) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } else { - if (averageDuration_2 <= 6.196000814437866) { - if (cpuCoreIdleTimesPercentage_2_2 <= -1.4520399570465088) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.012336883693933487) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.3307592868804932) { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.6011559367179871) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.15307504683732986) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6843329668045044) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.4513207077980042) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 5.6075217723846436) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.373752474784851) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6345682740211487) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.4803755283355713) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.832883596420288) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -1.808729112148285) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.21225882321596146) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.844688057899475) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.41048693656921387) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.4960800111293793) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.553554117679596) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.2230907753109932) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3361176252365112) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.122180223464966) { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9718023836612701) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 4.569088697433472) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5646337866783142) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2898950576782227) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.5634623765945435) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.2467628717422485) { - if (cpuCoreIdleTimesPercentage_1_2 <= -1.9045336842536926) { - if (cpuCoreIdleTimesPercentage_0_2 <= -2.4556432962417603) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.454709768295288) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.5829074382781982) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (maxDuration_2 <= 4.546690940856934) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.4269262552261353) { - if (averageDuration_2 <= 6.02677845954895) { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.7006368041038513) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.8963220119476318) { - if (averageDuration_2 <= 4.786563158035278) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9241895377635956) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (averageDuration_2 <= 5.745266437530518) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.2836057543754578) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= 5.0169923305511475) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.25446879863739) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.990395188331604) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.25149398297071457) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.29162634164094925) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.4340621829032898) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= -0.9057652652263641) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } else { - if (averageDuration_2 <= 7.0189292430877686) { - if (maxDuration_2 <= 6.2119410037994385) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.27731649577617645) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.07794911041855812) { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.9897132813930511) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.5090467035770416) { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.7804611325263977) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.3819066286087036) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.28432607650756836) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.21866188943386078) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.1997483372688293) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 6.9840497970581055) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.07530201226472855) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (averageDuration_2 <= 8.04335618019104) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (maxDuration_2 <= 5.035607099533081) { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.6760538816452026) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9544653296470642) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 1.4360809326171875) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.916453778743744) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.158440463244915) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.9223034381866455) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.17166617512702942) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (maxDuration_2 <= 5.225733757019043) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuCoreIdleTimesPercentage_4_2 <= 0.30665166676044464) { - if (cpuCoreIdleTimesPercentage_6_2 <= -3.181956171989441) { - if (cpuCoreIdleTimesPercentage_5_2 <= -1.5000993013381958) { - if (maxDuration_2 <= 6.364424705505371) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.2087278366088867) { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.9995294213294983) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.1508285440504551) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.5535541474819183) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.9250659346580505) { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.1936676949262619) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -2.423102855682373) { - if (cpuCoreIdleTimesPercentage_4_2 <= -0.8096396028995514) { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.4106956720352173) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.8706079125404358) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.914979875087738) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (averageDuration_2 <= 8.337781429290771) { - if (cpuCoreIdleTimesPercentage_3_2 <= -1.2385960221290588) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.35311898589134216) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7750936150550842) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= -2.762808322906494) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } - } - } - } else { - if (averageDuration_2 <= 9.630945205688477) { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.373752474784851) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.7669174075126648) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6364741921424866) { - if (cpuCoreIdleTimesPercentage_2_2 <= 0.33403678238391876) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6809051632881165) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.9963940382003784) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= -0.2523229196667671) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.13044001534581184) { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.372219517827034) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 2.811887502670288) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_6_2 <= -0.18870143964886665) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 2.146018385887146) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_3_2 <= -0.23118147999048233) { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.0320334732532501) { - if (averageDuration_2 <= 9.192076683044434) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.6117304563522339) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } else { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6280301809310913) { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.36219175159931183) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -0.19345904886722565) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.2613963410258293) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - if (cpuCoreIdleTimesPercentage_0_2 <= -0.21300741285085678) { - if (cpuCoreIdleTimesPercentage_6_2 <= -1.5799325108528137) { - if (cpuCoreIdleTimesPercentage_1_2 <= -0.033935023471713066) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_5_2 <= 0.9432739317417145) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } else { - if (cpuPolicyAverageFrequencyHz_0_2 <= 0.6918853223323822) { - if (cpuPolicyAverageFrequencyHz_2_2 <= 1.6562197804450989) { - if (cpuPolicyAverageFrequencyHz_1_2 <= 0.40245582163333893) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_2_2 <= -0.23426035046577454) { - if (cpuCoreIdleTimesPercentage_3_2 <= 0.29267410933971405) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuPolicyAverageFrequencyHz_1_2 <= 1.314504325389862) { - return ThrottleDecision::NO_THROTTLE; - } else { - return ThrottleDecision::THROTTLE_70; - } - } - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -1.5351781249046326) { - if (cpuCoreIdleTimesPercentage_0_2 <= 0.0026306556537747383) { - return ThrottleDecision::NO_THROTTLE; - } else { - if (cpuCoreIdleTimesPercentage_1_2 <= 0.1421213187277317) { - return ThrottleDecision::THROTTLE_70; - } else { - if (cpuCoreIdleTimesPercentage_7_2 <= -2.2479664087295532) { - return ThrottleDecision::THROTTLE_70; - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } else { - return ThrottleDecision::NO_THROTTLE; - } - } - } - } - } - } - } - } - } - } - } - } diff --git a/power-libperfmgr/adaptivecpu/tests/AdaptiveCpuConfigTest.cpp b/power-libperfmgr/adaptivecpu/tests/AdaptiveCpuConfigTest.cpp deleted file mode 100644 index e16515be..00000000 --- a/power-libperfmgr/adaptivecpu/tests/AdaptiveCpuConfigTest.cpp +++ /dev/null @@ -1,131 +0,0 @@ -/* - * 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. - */ - -#include <android-base/properties.h> -#include <gtest/gtest.h> - -#include "adaptivecpu/AdaptiveCpuConfig.h" - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -using std::chrono_literals::operator""ms; -using std::chrono_literals::operator""min; - -class AdaptiveCpuConfigTest : public ::testing::Test { - protected: - void SetUp() override { - android::base::SetProperty("debug.adaptivecpu.iteration_sleep_duration_ms", ""); - android::base::SetProperty("debug.adaptivecpu.hint_timeout_ms", ""); - android::base::SetProperty("debug.adaptivecpu.random_throttle_decision_percent", ""); - android::base::SetProperty("debug.adaptivecpu.random_throttle_options", ""); - android::base::SetProperty("debug.adaptivecpu.enabled_hint_timeout_ms", ""); - } -}; - -TEST(AdaptiveCpuConfigTest, valid) { - android::base::SetProperty("debug.adaptivecpu.iteration_sleep_duration_ms", "25"); - android::base::SetProperty("debug.adaptivecpu.hint_timeout_ms", "500"); - android::base::SetProperty("debug.adaptivecpu.random_throttle_decision_percent", "25"); - android::base::SetProperty("debug.adaptivecpu.random_throttle_options", "0,3,4"); - android::base::SetProperty("debug.adaptivecpu.enabled_hint_timeout_ms", "1000"); - const AdaptiveCpuConfig expectedConfig{ - .iterationSleepDuration = 25ms, - .hintTimeout = 500ms, - .randomThrottleDecisionProbability = 0.25, - .enabledHintTimeout = 1000ms, - .randomThrottleOptions = {ThrottleDecision::NO_THROTTLE, ThrottleDecision::THROTTLE_70, - ThrottleDecision::THROTTLE_80}, - }; - AdaptiveCpuConfig actualConfig; - ASSERT_TRUE(AdaptiveCpuConfig::ReadFromSystemProperties(&actualConfig)); - ASSERT_EQ(actualConfig, expectedConfig); -} - -TEST(AdaptiveCpuConfigTest, defaultConfig) { - android::base::SetProperty("debug.adaptivecpu.iteration_sleep_duration_ms", ""); - android::base::SetProperty("debug.adaptivecpu.hint_timeout_ms", ""); - android::base::SetProperty("debug.adaptivecpu.random_throttle_decision_percent", ""); - android::base::SetProperty("debug.adaptivecpu.random_throttle_options", ""); - android::base::SetProperty("debug.adaptivecpu.enabled_hint_timeout_ms", ""); - AdaptiveCpuConfig actualConfig; - ASSERT_TRUE(AdaptiveCpuConfig::ReadFromSystemProperties(&actualConfig)); - ASSERT_EQ(actualConfig, AdaptiveCpuConfig::DEFAULT); -} - -TEST(AdaptiveCpuConfigTest, iterationSleepDuration_belowMin) { - android::base::SetProperty("debug.adaptivecpu.iteration_sleep_duration_ms", "2"); - AdaptiveCpuConfig actualConfig; - ASSERT_TRUE(AdaptiveCpuConfig::ReadFromSystemProperties(&actualConfig)); - ASSERT_EQ(actualConfig.iterationSleepDuration, 20ms); -} - -TEST(AdaptiveCpuConfigTest, iterationSleepDuration_negative) { - android::base::SetProperty("debug.adaptivecpu.iteration_sleep_duration_ms", "-100"); - AdaptiveCpuConfig actualConfig; - ASSERT_TRUE(AdaptiveCpuConfig::ReadFromSystemProperties(&actualConfig)); - ASSERT_EQ(actualConfig.iterationSleepDuration, 1000ms); -} - -TEST(AdaptiveCpuConfigTest, randomThrottleDecisionProbability_float) { - android::base::SetProperty("debug.adaptivecpu.random_throttle_decision_percent", "0.5"); - AdaptiveCpuConfig actualConfig; - ASSERT_TRUE(AdaptiveCpuConfig::ReadFromSystemProperties(&actualConfig)); - ASSERT_EQ(actualConfig.randomThrottleDecisionProbability, 0); -} - -TEST(AdaptiveCpuConfigTest, randomThrottleDecisionProbability_tooBig) { - android::base::SetProperty("debug.adaptivecpu.random_throttle_decision_percent", "101"); - AdaptiveCpuConfig actualConfig; - ASSERT_FALSE(AdaptiveCpuConfig::ReadFromSystemProperties(&actualConfig)); -} - -TEST(AdaptiveCpuConfigTest, randomThrottleOptions_invalidThrottle) { - android::base::SetProperty("debug.adaptivecpu.random_throttle_options", "0,1,2,9"); - AdaptiveCpuConfig actualConfig; - ASSERT_FALSE(AdaptiveCpuConfig::ReadFromSystemProperties(&actualConfig)); -} - -TEST(AdaptiveCpuConfigTest, randomThrottleOptions_wrongDelim) { - android::base::SetProperty("debug.adaptivecpu.random_throttle_options", "0,1.2,3"); - AdaptiveCpuConfig actualConfig; - ASSERT_FALSE(AdaptiveCpuConfig::ReadFromSystemProperties(&actualConfig)); -} - -TEST(AdaptiveCpuConfigTest, randomThrottleOptions_wrongNumber) { - android::base::SetProperty("debug.adaptivecpu.random_throttle_options", "0,1,2a,3"); - AdaptiveCpuConfig actualConfig; - ASSERT_FALSE(AdaptiveCpuConfig::ReadFromSystemProperties(&actualConfig)); -} - -TEST(AdaptiveCpuConfigTest, randomThrottleOptions_straySpace) { - android::base::SetProperty("debug.adaptivecpu.random_throttle_options", "0,1 ,2,3"); - AdaptiveCpuConfig actualConfig; - ASSERT_FALSE(AdaptiveCpuConfig::ReadFromSystemProperties(&actualConfig)); - android::base::SetProperty("debug.adaptivecpu.random_throttle_options", "0,1,2,3 "); - ASSERT_FALSE(AdaptiveCpuConfig::ReadFromSystemProperties(&actualConfig)); -} - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/tests/AdaptiveCpuStatsTest.cpp b/power-libperfmgr/adaptivecpu/tests/AdaptiveCpuStatsTest.cpp deleted file mode 100644 index 09797295..00000000 --- a/power-libperfmgr/adaptivecpu/tests/AdaptiveCpuStatsTest.cpp +++ /dev/null @@ -1,129 +0,0 @@ - -/* - * 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. - */ - -#include <gtest/gtest.h> - -#include "adaptivecpu/AdaptiveCpuStats.h" -#include "mocks.h" - -using testing::HasSubstr; -using testing::Return; -using std::chrono_literals::operator""ns; - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -TEST(AdaptiveCpuStatsTest, singleRun) { - std::unique_ptr<MockTimeSource> timeSource = std::make_unique<MockTimeSource>(); - - EXPECT_CALL(*timeSource, GetTime()) - .Times(3) - .WillOnce(Return(1000ns)) - .WillOnce(Return(1100ns)) - .WillOnce(Return(1200ns)); - - AdaptiveCpuStats stats(std::move(timeSource)); - stats.RegisterStartRun(); - stats.RegisterSuccessfulRun(ThrottleDecision::NO_THROTTLE, ThrottleDecision::THROTTLE_60, {}, - AdaptiveCpuConfig::DEFAULT); - - std::stringstream stream; - stats.DumpToStream(stream); - EXPECT_THAT(stream.str(), HasSubstr("- Successful runs / total runs: 1 / 1\n")); - EXPECT_THAT(stream.str(), HasSubstr("- Total run duration: 100.000000ns\n")); - EXPECT_THAT(stream.str(), HasSubstr("- Average run duration: 100.000000ns\n")); - EXPECT_THAT(stream.str(), HasSubstr("- Running time fraction: 0.5\n")); - EXPECT_THAT(stream.str(), HasSubstr("- THROTTLE_60: 1\n")); -} - -TEST(AdaptiveCpuStatsTest, multipleRuns) { - std::unique_ptr<MockTimeSource> timeSource = std::make_unique<MockTimeSource>(); - - EXPECT_CALL(*timeSource, GetTime()) - .Times(9) - .WillOnce(Return(1000ns)) // start #1 - .WillOnce(Return(1100ns)) // success #1 - .WillOnce(Return(2000ns)) // start #2 - .WillOnce(Return(2200ns)) // success #2 - .WillOnce(Return(3000ns)) // start #3 - .WillOnce(Return(3100ns)) // success #3 - .WillOnce(Return(4000ns)) // start #4 - .WillOnce(Return(4800ns)) // success #4 - .WillOnce(Return(5000ns)); // dump - - AdaptiveCpuStats stats(std::move(timeSource)); - stats.RegisterStartRun(); - stats.RegisterSuccessfulRun(ThrottleDecision::NO_THROTTLE, ThrottleDecision::THROTTLE_60, - // Ignored, as this is the first call. - {.numDurations = 100000, .numMissedDeadlines = 123}, - AdaptiveCpuConfig::DEFAULT); - stats.RegisterStartRun(); - stats.RegisterSuccessfulRun(ThrottleDecision::THROTTLE_60, ThrottleDecision::THROTTLE_70, - {.numDurations = 100, .numMissedDeadlines = 10}, - AdaptiveCpuConfig::DEFAULT); - stats.RegisterStartRun(); - stats.RegisterSuccessfulRun(ThrottleDecision::THROTTLE_70, ThrottleDecision::THROTTLE_60, - {.numDurations = 50, .numMissedDeadlines = 1}, - AdaptiveCpuConfig::DEFAULT); - stats.RegisterStartRun(); - stats.RegisterSuccessfulRun(ThrottleDecision::THROTTLE_60, ThrottleDecision::THROTTLE_80, - {.numDurations = 200, .numMissedDeadlines = 20}, - AdaptiveCpuConfig::DEFAULT); - - std::stringstream stream; - stats.DumpToStream(stream); - EXPECT_THAT(stream.str(), HasSubstr("- Successful runs / total runs: 4 / 4\n")); - EXPECT_THAT(stream.str(), HasSubstr("- Total run duration: 1.200000us\n")); - EXPECT_THAT(stream.str(), HasSubstr("- Average run duration: 300.000000ns\n")); - EXPECT_THAT(stream.str(), HasSubstr("- Running time fraction: 0.3\n")); - EXPECT_THAT(stream.str(), HasSubstr("- THROTTLE_60: 2\n")); - EXPECT_THAT(stream.str(), HasSubstr("- THROTTLE_70: 1\n")); - EXPECT_THAT(stream.str(), HasSubstr("- THROTTLE_60: 30 / 300 (0.1)\n")); - EXPECT_THAT(stream.str(), HasSubstr("- THROTTLE_70: 1 / 50 (0.02)\n")); -} - -TEST(AdaptiveCpuStatsTest, failedRun) { - std::unique_ptr<MockTimeSource> timeSource = std::make_unique<MockTimeSource>(); - - EXPECT_CALL(*timeSource, GetTime()) - .Times(4) - .WillOnce(Return(1000ns)) - .WillOnce(Return(1100ns)) - .WillOnce(Return(1200ns)) - .WillOnce(Return(1300ns)); - - AdaptiveCpuStats stats(std::move(timeSource)); - stats.RegisterStartRun(); - stats.RegisterStartRun(); - stats.RegisterSuccessfulRun(ThrottleDecision::NO_THROTTLE, ThrottleDecision::THROTTLE_60, {}, - AdaptiveCpuConfig::DEFAULT); - - std::stringstream stream; - stats.DumpToStream(stream); - EXPECT_THAT(stream.str(), HasSubstr("- Successful runs / total runs: 1 / 2\n")); -} - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/tests/CpuFrequencyReaderTest.cpp b/power-libperfmgr/adaptivecpu/tests/CpuFrequencyReaderTest.cpp deleted file mode 100644 index ea3e738d..00000000 --- a/power-libperfmgr/adaptivecpu/tests/CpuFrequencyReaderTest.cpp +++ /dev/null @@ -1,159 +0,0 @@ -/* - * 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. - */ - -#include <gtest/gtest.h> - -#include "adaptivecpu/CpuFrequencyReader.h" -#include "mocks.h" - -using testing::_; -using testing::ByMove; -using testing::Return; -using std::chrono_literals::operator""ms; - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -std::ostream &operator<<(std::ostream &stream, const CpuPolicyAverageFrequency &frequency) { - return stream << "CpuPolicyAverageFrequency(" << frequency.policyId << ", " - << frequency.averageFrequencyHz << ")"; -} - -TEST(CpuFrequencyReaderTest, cpuPolicyIds) { - std::unique_ptr<MockFilesystem> filesystem = std::make_unique<MockFilesystem>(); - EXPECT_CALL(*filesystem, ListDirectory("/sys/devices/system/cpu/cpufreq", _)) - .WillOnce([](auto _path __attribute__((unused)), auto result) { - *result = std::vector<std::string>{"ignored1", "policy1", "ignored2", - "policy5", "policy10", "policybad"}; - return true; - }); - EXPECT_CALL(*filesystem, ReadFileStream(_, _)) - .WillRepeatedly([](auto _path __attribute__((unused)), auto result) { - *result = std::make_unique<std::istringstream>("1 2\n3 4\n"); - return true; - }); - - CpuFrequencyReader reader(std::move(filesystem)); - EXPECT_TRUE(reader.Init()); - - std::map<uint32_t, std::map<uint64_t, std::chrono::milliseconds>> expected = { - {1, {{1, 20ms}, {3, 40ms}}}, {5, {{1, 20ms}, {3, 40ms}}}, {10, {{1, 20ms}, {3, 40ms}}}}; - EXPECT_EQ(reader.GetPreviousCpuPolicyFrequencies(), expected); -} - -TEST(CpuFrequencyReaderTest, getRecentCpuPolicyFrequencies) { - std::unique_ptr<MockFilesystem> filesystem = std::make_unique<MockFilesystem>(); - EXPECT_CALL(*filesystem, ListDirectory("/sys/devices/system/cpu/cpufreq", _)) - .WillOnce([](auto _path __attribute__((unused)), auto result) { - *result = std::vector<std::string>{"policy1", "policy2"}; - return true; - }); - EXPECT_CALL(*filesystem, - ReadFileStream("/sys/devices/system/cpu/cpufreq/policy1/stats/time_in_state", _)) - .Times(2) - .WillOnce([](auto _path __attribute__((unused)), auto result) { - *result = std::make_unique<std::istringstream>("1000 5\n2000 4"); - return true; - }) - .WillOnce([](auto _path __attribute__((unused)), auto result) { - *result = std::make_unique<std::istringstream>("1000 7\n2000 10"); - return true; - }); - EXPECT_CALL(*filesystem, - ReadFileStream("/sys/devices/system/cpu/cpufreq/policy2/stats/time_in_state", _)) - .Times(2) - .WillOnce([](auto _path __attribute__((unused)), auto result) { - *result = std::make_unique<std::istringstream>("1500 1\n2500 23"); - return true; - }) - .WillOnce([](auto _path __attribute__((unused)), auto result) { - *result = std::make_unique<std::istringstream>("1500 5\n2500 23"); - return true; - }); - - CpuFrequencyReader reader(std::move(filesystem)); - EXPECT_TRUE(reader.Init()); - - std::vector<CpuPolicyAverageFrequency> actual; - EXPECT_TRUE(reader.GetRecentCpuPolicyFrequencies(&actual)); - EXPECT_EQ(actual, std::vector<CpuPolicyAverageFrequency>({ - {.policyId = 1, .averageFrequencyHz = 1750}, - {.policyId = 2, .averageFrequencyHz = 1500}, - })); -} - -TEST(CpuFrequencyReaderTest, getRecentCpuPolicyFrequencies_frequenciesChange) { - std::unique_ptr<MockFilesystem> filesystem = std::make_unique<MockFilesystem>(); - EXPECT_CALL(*filesystem, ListDirectory("/sys/devices/system/cpu/cpufreq", _)) - .WillOnce([](auto _path __attribute__((unused)), auto result) { - *result = std::vector<std::string>{"policy1"}; - return true; - }); - EXPECT_CALL(*filesystem, - ReadFileStream("/sys/devices/system/cpu/cpufreq/policy1/stats/time_in_state", _)) - .Times(2) - .WillOnce([](auto _path __attribute__((unused)), auto result) { - *result = std::make_unique<std::istringstream>("1000 5\n2000 4"); - return true; - }) - .WillOnce([](auto _path __attribute__((unused)), auto result) { - *result = std::make_unique<std::istringstream>("1000 6\n2001 4"); - return true; - }); - - CpuFrequencyReader reader(std::move(filesystem)); - EXPECT_TRUE(reader.Init()); - - std::vector<CpuPolicyAverageFrequency> actual; - EXPECT_FALSE(reader.GetRecentCpuPolicyFrequencies(&actual)); -} - -TEST(CpuFrequencyReaderTest, getRecentCpuPolicyFrequencies_badFormat) { - std::unique_ptr<MockFilesystem> filesystem = std::make_unique<MockFilesystem>(); - EXPECT_CALL(*filesystem, ListDirectory("/sys/devices/system/cpu/cpufreq", _)) - .WillOnce([](auto _path __attribute__((unused)), auto result) { - *result = std::vector<std::string>{"policy1"}; - return true; - }); - EXPECT_CALL(*filesystem, - ReadFileStream("/sys/devices/system/cpu/cpufreq/policy1/stats/time_in_state", _)) - .Times(2) - .WillOnce([](auto _path __attribute__((unused)), auto result) { - *result = std::make_unique<std::istringstream>("1000 1"); - return true; - }) - .WillOnce([](auto _path __attribute__((unused)), auto result) { - *result = std::make_unique<std::istringstream>("1000 2\nfoo"); - return true; - }); - - CpuFrequencyReader reader(std::move(filesystem)); - EXPECT_TRUE(reader.Init()); - - std::vector<CpuPolicyAverageFrequency> actual; - EXPECT_FALSE(reader.GetRecentCpuPolicyFrequencies(&actual)); -} - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/tests/CpuLoadReaderProcStatTest.cpp b/power-libperfmgr/adaptivecpu/tests/CpuLoadReaderProcStatTest.cpp deleted file mode 100644 index a090fc22..00000000 --- a/power-libperfmgr/adaptivecpu/tests/CpuLoadReaderProcStatTest.cpp +++ /dev/null @@ -1,139 +0,0 @@ -/* - * 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. - */ - -#include <gtest/gtest.h> - -#include "adaptivecpu/CpuLoadReaderProcStat.h" -#include "mocks.h" - -#define LOG_TAG "powerhal-adaptivecpu" - -using testing::_; -using testing::ByMove; -using testing::Return; - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -TEST(CpuLoadReaderProcStatTest, GetRecentCpuLoads) { - std::unique_ptr<MockFilesystem> filesystem = std::make_unique<MockFilesystem>(); - EXPECT_CALL(*filesystem, ReadFileStream("/proc/stat", _)) - .Times(2) - .WillOnce([](auto _path __attribute__((unused)), auto result) { - std::stringstream ss; - ss << "bad line\n"; - ss << "cpu1 100 0 0 50 0 0 0 0 0 0\n"; - ss << "cpu2 200 0 0 50 0 0 0 0 0 0\n"; - *result = std::make_unique<std::istringstream>(ss.str()); - return true; - }) - .WillOnce([](auto _path __attribute__((unused)), auto result) { - std::stringstream ss; - ss << "bad line\n"; - ss << "cpu1 200 0 0 150 0 0 0 0 0 0\n"; - ss << "cpu2 500 0 0 150 0 0 0 0 0 0\n"; - *result = std::make_unique<std::istringstream>(ss.str()); - return true; - }); - - CpuLoadReaderProcStat reader(std::move(filesystem)); - reader.Init(); - - std::array<double, NUM_CPU_CORES> actualPercentages; - ASSERT_TRUE(reader.GetRecentCpuLoads(&actualPercentages)); - std::array<double, NUM_CPU_CORES> expectedPercentages({0, 0.5, 0.25, 0, 0, 0, 0, 0}); - ASSERT_EQ(actualPercentages, expectedPercentages); -} - -TEST(CpuLoadReaderProcStatTest, GetRecentCpuLoads_failsWithMissingValues) { - std::unique_ptr<MockFilesystem> filesystem = std::make_unique<MockFilesystem>(); - EXPECT_CALL(*filesystem, ReadFileStream("/proc/stat", _)) - .Times(2) - .WillOnce([](auto _path __attribute__((unused)), auto result) { - std::stringstream ss; - ss << "bad line\n"; - ss << "cpu1 100 0 0 50 0 0 0\n"; - ss << "cpu2 200 0 0 50 0 0 0\n"; - *result = std::make_unique<std::istringstream>(ss.str()); - return true; - }) - .WillOnce([](auto _path __attribute__((unused)), auto result) { - std::stringstream ss; - ss << "bad line\n"; - ss << "cpu1 200 0 0 150 0 0 0\n"; - ss << "cpu2 500 0 0 150 0 0 0\n"; - *result = std::make_unique<std::istringstream>(ss.str()); - return true; - }); - - CpuLoadReaderProcStat reader(std::move(filesystem)); - reader.Init(); - std::array<double, NUM_CPU_CORES> actualPercentages; - ASSERT_FALSE(reader.GetRecentCpuLoads(&actualPercentages)); -} - -TEST(CpuLoadReaderProcStatTest, GetRecentCpuLoads_failsWithEmptyFile) { - std::unique_ptr<MockFilesystem> filesystem = std::make_unique<MockFilesystem>(); - EXPECT_CALL(*filesystem, ReadFileStream("/proc/stat", _)) - .Times(2) - .WillRepeatedly([](auto _path __attribute__((unused)), auto result) { - *result = std::make_unique<std::istringstream>(""); - return true; - }); - - CpuLoadReaderProcStat reader(std::move(filesystem)); - reader.Init(); - std::array<double, NUM_CPU_CORES> actualPercentages; - ASSERT_FALSE(reader.GetRecentCpuLoads(&actualPercentages)); -} - -TEST(CpuLoadReaderProcStatTest, GetRecentCpuLoads_failsWithDifferentCpus) { - std::unique_ptr<MockFilesystem> filesystem = std::make_unique<MockFilesystem>(); - EXPECT_CALL(*filesystem, ReadFileStream("/proc/stat", _)) - .Times(2) - .WillOnce([](auto _path __attribute__((unused)), auto result) { - std::stringstream ss; - ss << "bad line\n"; - ss << "cpu1 100 0 0 50 0 0 0 0 0 0\n"; - ss << "cpu2 200 0 0 50 0 0 0 0 0 0\n"; - *result = std::make_unique<std::istringstream>(ss.str()); - return true; - }) - .WillOnce([](auto _path __attribute__((unused)), auto result) { - std::stringstream ss; - ss << "bad line\n"; - ss << "cpu1 200 0 0 150 0 0 0 0 0 0\n"; - ss << "cpu3 500 0 0 150 0 0 0 0 0 0\n"; - *result = std::make_unique<std::istringstream>(ss.str()); - return true; - }); - - CpuLoadReaderProcStat reader(std::move(filesystem)); - reader.Init(); - std::array<double, NUM_CPU_CORES> actualPercentages; - ASSERT_FALSE(reader.GetRecentCpuLoads(&actualPercentages)); -} - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/tests/CpuLoadReaderSysDevicesTest.cpp b/power-libperfmgr/adaptivecpu/tests/CpuLoadReaderSysDevicesTest.cpp deleted file mode 100644 index a860d789..00000000 --- a/power-libperfmgr/adaptivecpu/tests/CpuLoadReaderSysDevicesTest.cpp +++ /dev/null @@ -1,126 +0,0 @@ -/* - * 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. - */ - -#include <gtest/gtest.h> - -#include "adaptivecpu/CpuLoadReaderSysDevices.h" -#include "mocks.h" - -#define LOG_TAG "powerhal-adaptivecpu" - -using testing::_; -using testing::ByMove; -using testing::MatchesRegex; -using testing::Return; -using std::chrono_literals::operator""ms; - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -TEST(CpuLoadReaderSysDevicesTest, GetRecentCpuLoads) { - std::unique_ptr<MockFilesystem> filesystem = std::make_unique<MockFilesystem>(); - std::unique_ptr<MockTimeSource> timeSource = std::make_unique<MockTimeSource>(); - EXPECT_CALL(*filesystem, ListDirectory(MatchesRegex("/sys/devices/system/cpu/cpu0/cpuidle"), _)) - .WillOnce([](auto _path __attribute__((unused)), auto result) { - *result = std::vector<std::string>{"foo", "bar", "baz"}; - return true; - }); - EXPECT_CALL(*filesystem, - ListDirectory(MatchesRegex("/sys/devices/system/cpu/cpu0/cpuidle/(foo|bar)"), _)) - .Times(2) - .WillRepeatedly([](auto _path __attribute__((unused)), auto result) { - *result = std::vector<std::string>{"abc", "time", "xyz"}; - return true; - }); - EXPECT_CALL(*filesystem, - ListDirectory(MatchesRegex("/sys/devices/system/cpu/cpu0/cpuidle/baz"), _)) - .WillOnce([](auto _path __attribute__((unused)), auto result) { - *result = std::vector<std::string>{"abc", "xyz"}; - return true; - }); - - EXPECT_CALL(*filesystem, ReadFileStream("/sys/devices/system/cpu/cpu0/cpuidle/foo/time", _)) - .Times(2) - .WillOnce([](auto _path __attribute__((unused)), auto result) { - *result = std::make_unique<std::istringstream>("100"); - return true; - }) - .WillOnce([](auto _path __attribute__((unused)), auto result) { - *result = std::make_unique<std::istringstream>("200"); - return true; - }); - EXPECT_CALL(*filesystem, ReadFileStream("/sys/devices/system/cpu/cpu0/cpuidle/bar/time", _)) - .Times(2) - .WillOnce([](auto _path __attribute__((unused)), auto result) { - *result = std::make_unique<std::istringstream>("500"); - return true; - }) - .WillOnce([](auto _path __attribute__((unused)), auto result) { - *result = std::make_unique<std::istringstream>("700"); - return true; - }); - - EXPECT_CALL(*filesystem, ReadFileStream("/sys/devices/system/cpu/cpu1/cpuidle/foo/time", _)) - .Times(2) - .WillOnce([](auto _path __attribute__((unused)), auto result) { - *result = std::make_unique<std::istringstream>("1000"); - return true; - }) - .WillOnce([](auto _path __attribute__((unused)), auto result) { - *result = std::make_unique<std::istringstream>("1010"); - return true; - }); - EXPECT_CALL(*filesystem, ReadFileStream("/sys/devices/system/cpu/cpu1/cpuidle/bar/time", _)) - .Times(2) - .WillOnce([](auto _path __attribute__((unused)), auto result) { - *result = std::make_unique<std::istringstream>("50"); - return true; - }) - .WillOnce([](auto _path __attribute__((unused)), auto result) { - *result = std::make_unique<std::istringstream>("70"); - return true; - }); - - EXPECT_CALL(*filesystem, - ReadFileStream( - MatchesRegex("/sys/devices/system/cpu/cpu[2-7]/cpuidle/(foo|bar)/time"), _)) - .WillRepeatedly([](auto _path __attribute__((unused)), auto result) { - *result = std::make_unique<std::istringstream>("0"); - return true; - }); - - EXPECT_CALL(*timeSource, GetTime()).Times(2).WillOnce(Return(1ms)).WillOnce(Return(2ms)); - - CpuLoadReaderSysDevices reader(std::move(filesystem), std::move(timeSource)); - ASSERT_TRUE(reader.Init()); - - std::array<double, NUM_CPU_CORES> actualPercentage; - reader.GetRecentCpuLoads(&actualPercentage); - - std::array<double, NUM_CPU_CORES> expectedPercentage{0.3, 0.03, 0, 0, 0, 0, 0, 0}; - ASSERT_EQ(actualPercentage, expectedPercentage); -} - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/tests/KernelCpuFeatureReaderTest.cpp b/power-libperfmgr/adaptivecpu/tests/KernelCpuFeatureReaderTest.cpp deleted file mode 100644 index 9e0ba030..00000000 --- a/power-libperfmgr/adaptivecpu/tests/KernelCpuFeatureReaderTest.cpp +++ /dev/null @@ -1,211 +0,0 @@ -/* - * Copyright (C) 2022 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. - */ - -#include <gtest/gtest.h> - -#include "adaptivecpu/KernelCpuFeatureReader.h" -#include "mocks.h" - -using testing::_; -using testing::ByMove; -using testing::MatchesRegex; -using testing::Return; -using std::chrono_literals::operator""ns; - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -TEST(KernelCpuFeatureReaderTest, valid) { - std::unique_ptr<MockFilesystem> filesystem = std::make_unique<MockFilesystem>(); - std::unique_ptr<MockTimeSource> timeSource = std::make_unique<MockTimeSource>(); - - EXPECT_CALL(*timeSource, GetKernelTime()) - .Times(2) - .WillOnce(Return(100ns)) - .WillOnce(Return(200ns)); - - EXPECT_CALL(*filesystem, ReadFileStream("/proc/vendor_sched/acpu_stats", _)) - .WillOnce([](auto path __attribute__((unused)), auto result) { - // Empty file, we will populate in ResetFileStream. - *result = std::make_unique<std::istringstream>(""); - return true; - }); - - EXPECT_CALL(*filesystem, ResetFileStream(_)) - .Times(2) - .WillOnce([](auto &result) { - std::array<acpu_stats, NUM_CPU_CORES> acpuStats{{ - {.weighted_sum_freq = 100, .total_idle_time_ns = 100}, - {.weighted_sum_freq = 100, .total_idle_time_ns = 100}, - {.weighted_sum_freq = 100, .total_idle_time_ns = 100}, - {.weighted_sum_freq = 100, .total_idle_time_ns = 100}, - {.weighted_sum_freq = 200, .total_idle_time_ns = 200}, - {.weighted_sum_freq = 200, .total_idle_time_ns = 200}, - {.weighted_sum_freq = 300, .total_idle_time_ns = 200}, - {.weighted_sum_freq = 300, .total_idle_time_ns = 200}, - }}; - char *bytes = reinterpret_cast<char *>(acpuStats.begin()); - static_cast<std::istringstream &>(*result).str( - std::string(bytes, bytes + sizeof(acpuStats))); - return true; - }) - .WillOnce([](auto &result) { - std::array<acpu_stats, NUM_CPU_CORES> acpuStats{{ - {.weighted_sum_freq = 200, .total_idle_time_ns = 150}, - {.weighted_sum_freq = 100, .total_idle_time_ns = 150}, - {.weighted_sum_freq = 100, .total_idle_time_ns = 150}, - {.weighted_sum_freq = 100, .total_idle_time_ns = 150}, - {.weighted_sum_freq = 300, .total_idle_time_ns = 300}, - {.weighted_sum_freq = 200, .total_idle_time_ns = 300}, - {.weighted_sum_freq = 400, .total_idle_time_ns = 300}, - {.weighted_sum_freq = 300, .total_idle_time_ns = 300}, - }}; - char *bytes = reinterpret_cast<char *>(acpuStats.begin()); - static_cast<std::istringstream &>(*result).str( - std::string(bytes, bytes + sizeof(acpuStats))); - return true; - }); - - KernelCpuFeatureReader reader(std::move(filesystem), std::move(timeSource)); - ASSERT_TRUE(reader.Init()); - - std::array<double, NUM_CPU_POLICIES> cpuPolicyAverageFrequencyHz; - std::array<double, NUM_CPU_CORES> cpuCoreIdleTimesPercentage; - ASSERT_TRUE( - reader.GetRecentCpuFeatures(&cpuPolicyAverageFrequencyHz, &cpuCoreIdleTimesPercentage)); - std::array<double, NUM_CPU_POLICIES> expectedFrequencies{{1, 1, 1}}; - std::array<double, NUM_CPU_CORES> expectedIdleTimes{{0.5, 0.5, 0.5, 0.5, 1, 1, 1, 1}}; - ASSERT_EQ(cpuPolicyAverageFrequencyHz, expectedFrequencies); - ASSERT_EQ(cpuCoreIdleTimesPercentage, expectedIdleTimes); -} - -TEST(KernelCpuFeatureReaderTest, noFile) { - std::unique_ptr<MockFilesystem> filesystem = std::make_unique<MockFilesystem>(); - std::unique_ptr<MockTimeSource> timeSource = std::make_unique<MockTimeSource>(); - - EXPECT_CALL(*filesystem, ReadFileStream("/proc/vendor_sched/acpu_stats", _)) - .WillOnce(Return(false)); - - KernelCpuFeatureReader reader(std::move(filesystem), std::move(timeSource)); - ASSERT_FALSE(reader.Init()); -} - -TEST(KernelCpuFeatureReaderTest, frequencies_capsNegativeDiff) { - std::unique_ptr<MockFilesystem> filesystem = std::make_unique<MockFilesystem>(); - std::unique_ptr<MockTimeSource> timeSource = std::make_unique<MockTimeSource>(); - - EXPECT_CALL(*timeSource, GetKernelTime()) - .Times(2) - .WillOnce(Return(100ns)) - .WillOnce(Return(200ns)); - - EXPECT_CALL(*filesystem, ReadFileStream("/proc/vendor_sched/acpu_stats", _)) - .WillOnce([](auto path __attribute__((unused)), auto result) { - // Empty file, we will populate in ResetFileStream. - *result = std::make_unique<std::istringstream>(""); - return true; - }); - - EXPECT_CALL(*filesystem, ResetFileStream(_)) - .Times(2) - .WillOnce([](auto &result) { - std::array<acpu_stats, NUM_CPU_CORES> acpuStats{{ - {.weighted_sum_freq = 200, .total_idle_time_ns = 100}, - }}; - char *bytes = reinterpret_cast<char *>(acpuStats.begin()); - static_cast<std::istringstream &>(*result).str( - std::string(bytes, bytes + sizeof(acpuStats))); - return true; - }) - .WillOnce([](auto &result) { - std::array<acpu_stats, NUM_CPU_CORES> acpuStats{{ - {.weighted_sum_freq = 100, .total_idle_time_ns = 150}, - }}; - char *bytes = reinterpret_cast<char *>(acpuStats.begin()); - static_cast<std::istringstream &>(*result).str( - std::string(bytes, bytes + sizeof(acpuStats))); - return true; - }); - - KernelCpuFeatureReader reader(std::move(filesystem), std::move(timeSource)); - ASSERT_TRUE(reader.Init()); - - std::array<double, NUM_CPU_POLICIES> cpuPolicyAverageFrequencyHz; - std::array<double, NUM_CPU_CORES> cpuCoreIdleTimesPercentage; - ASSERT_TRUE( - reader.GetRecentCpuFeatures(&cpuPolicyAverageFrequencyHz, &cpuCoreIdleTimesPercentage)); - std::array<double, NUM_CPU_POLICIES> expectedFrequencies{{0}}; - ASSERT_EQ(cpuPolicyAverageFrequencyHz, expectedFrequencies); -} - -TEST(KernelCpuFeatureReaderTest, idleTimes_capsNegativeDiff) { - std::unique_ptr<MockFilesystem> filesystem = std::make_unique<MockFilesystem>(); - std::unique_ptr<MockTimeSource> timeSource = std::make_unique<MockTimeSource>(); - - EXPECT_CALL(*timeSource, GetKernelTime()) - .Times(2) - .WillOnce(Return(100ns)) - .WillOnce(Return(200ns)); - - EXPECT_CALL(*filesystem, ReadFileStream("/proc/vendor_sched/acpu_stats", _)) - .WillOnce([](auto path __attribute__((unused)), auto result) { - // Empty file, we will populate in ResetFileStream. - *result = std::make_unique<std::istringstream>(""); - return true; - }); - - EXPECT_CALL(*filesystem, ResetFileStream(_)) - .Times(2) - .WillOnce([](auto &result) { - std::array<acpu_stats, NUM_CPU_CORES> acpuStats{{ - {.weighted_sum_freq = 100, .total_idle_time_ns = 150}, - }}; - char *bytes = reinterpret_cast<char *>(acpuStats.begin()); - static_cast<std::istringstream &>(*result).str( - std::string(bytes, bytes + sizeof(acpuStats))); - return true; - }) - .WillOnce([](auto &result) { - std::array<acpu_stats, NUM_CPU_CORES> acpuStats{{ - {.weighted_sum_freq = 200, .total_idle_time_ns = 100}, - }}; - char *bytes = reinterpret_cast<char *>(acpuStats.begin()); - static_cast<std::istringstream &>(*result).str( - std::string(bytes, bytes + sizeof(acpuStats))); - return true; - }); - - KernelCpuFeatureReader reader(std::move(filesystem), std::move(timeSource)); - ASSERT_TRUE(reader.Init()); - - std::array<double, NUM_CPU_POLICIES> cpuPolicyAverageFrequencyHz; - std::array<double, NUM_CPU_CORES> cpuCoreIdleTimesPercentage; - ASSERT_TRUE( - reader.GetRecentCpuFeatures(&cpuPolicyAverageFrequencyHz, &cpuCoreIdleTimesPercentage)); - std::array<double, NUM_CPU_CORES> expectedIdleTimes{{0}}; - ASSERT_EQ(cpuCoreIdleTimesPercentage, expectedIdleTimes); -} - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/tests/ModelTest.cpp b/power-libperfmgr/adaptivecpu/tests/ModelTest.cpp deleted file mode 100644 index 593725e6..00000000 --- a/power-libperfmgr/adaptivecpu/tests/ModelTest.cpp +++ /dev/null @@ -1,126 +0,0 @@ -/* - * 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. - */ - -#include <gtest/gtest.h> - -#include <random> -#include <set> - -#include "adaptivecpu/Model.h" -#include "mocks.h" - -using std::chrono_literals::operator""ns; -using testing::_; -using testing::ByMove; -using testing::Return; -using testing::UnorderedElementsAre; - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -TEST(ModelTest, ModelInput_SetCpuFreqiencies) { - const ModelInput expected{ - .cpuPolicyAverageFrequencyHz = {100, 101, 102}, - }; - ModelInput actual; - ASSERT_TRUE(actual.SetCpuFreqiencies({ - {.policyId = 0, .averageFrequencyHz = 100}, - {.policyId = 4, .averageFrequencyHz = 101}, - {.policyId = 6, .averageFrequencyHz = 102}, - })); - ASSERT_EQ(actual, expected); -} - -TEST(ModelTest, ModelInput_SetCpuFreqiencies_failsWithOutOfOrderFrquencies) { - ASSERT_FALSE(ModelInput().SetCpuFreqiencies({ - {.policyId = 0, .averageFrequencyHz = 100}, - {.policyId = 6, .averageFrequencyHz = 102}, - {.policyId = 4, .averageFrequencyHz = 101}, - })); -} - -TEST(ModelTest, Run_randomInputs) { - std::default_random_engine generator; - std::uniform_real_distribution<double> frequencyDistribution(0, 1e6); - std::uniform_real_distribution<double> idleTimesDistribution(0, 1); - std::uniform_int_distribution<uint32_t> frameTimeDistribution(1, 100); - std::uniform_int_distribution<uint16_t> numRenderedFramesDistribution(1, 20); - std::uniform_int_distribution<uint32_t> throttleDecisionDistribution(0, 3); - - const auto randomModelInput = [&]() { - return ModelInput{ - .cpuPolicyAverageFrequencyHz = {frequencyDistribution(generator), - frequencyDistribution(generator), - frequencyDistribution(generator)}, - .cpuCoreIdleTimesPercentage = - {idleTimesDistribution(generator), idleTimesDistribution(generator), - idleTimesDistribution(generator), idleTimesDistribution(generator), - idleTimesDistribution(generator), idleTimesDistribution(generator), - idleTimesDistribution(generator), idleTimesDistribution(generator)}, - .workDurationFeatures = - {.averageDuration = - std::chrono::nanoseconds(frameTimeDistribution(generator)), - .maxDuration = std::chrono::nanoseconds(frameTimeDistribution(generator)), - .numMissedDeadlines = numRenderedFramesDistribution(generator), - .numDurations = numRenderedFramesDistribution(generator)}, - .previousThrottleDecision = - static_cast<ThrottleDecision>(throttleDecisionDistribution(generator)), - }; - }; - - for (int i = 0; i < 10; i++) { - std::deque<ModelInput> modelInputs{randomModelInput(), randomModelInput(), - randomModelInput()}; - Model().Run(modelInputs, AdaptiveCpuConfig::DEFAULT); - } -} - -TEST(ModelTest, Run_randomThrottling) { - ModelInput modelInput{ - .cpuPolicyAverageFrequencyHz = {0, 0, 0}, - .cpuCoreIdleTimesPercentage = {0, 0, 0, 0, 0, 0, 0, 0}, - .workDurationFeatures = {.averageDuration = 0ns, - .maxDuration = 0ns, - .numMissedDeadlines = 0, - .numDurations = 0}, - .previousThrottleDecision = ThrottleDecision::NO_THROTTLE, - }; - std::deque<ModelInput> modelInputs{modelInput, modelInput, modelInput}; - - AdaptiveCpuConfig config = AdaptiveCpuConfig::DEFAULT; - config.randomThrottleOptions = {ThrottleDecision::THROTTLE_70, ThrottleDecision::THROTTLE_80}; - config.randomThrottleDecisionProbability = 1; - - std::set<ThrottleDecision> actualThrottleDecisions; - Model model; - for (int i = 0; i < 100; i++) { - ThrottleDecision throttleDecision = model.Run(modelInputs, config); - actualThrottleDecisions.insert(throttleDecision); - } - ASSERT_THAT(actualThrottleDecisions, - UnorderedElementsAre(ThrottleDecision::THROTTLE_70, ThrottleDecision::THROTTLE_80)); -} - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/tests/WorkDurationProcessorTest.cpp b/power-libperfmgr/adaptivecpu/tests/WorkDurationProcessorTest.cpp deleted file mode 100644 index 5699a219..00000000 --- a/power-libperfmgr/adaptivecpu/tests/WorkDurationProcessorTest.cpp +++ /dev/null @@ -1,126 +0,0 @@ -/* - * 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. - */ - -#include <gtest/gtest.h> - -#include "adaptivecpu/WorkDurationProcessor.h" - -using ::aidl::android::hardware::power::WorkDuration; -using std::chrono_literals::operator""ns; - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -static const std::chrono::nanoseconds kNormalTargetDuration = 16666666ns; - -TEST(WorkDurationProcessorTest, GetFeatures) { - WorkDurationProcessor processor; - ASSERT_TRUE(processor.ReportWorkDurations( - std::vector<WorkDuration>{ - {.timeStampNanos = 0, .durationNanos = kNormalTargetDuration.count()}, - {.timeStampNanos = 0, .durationNanos = kNormalTargetDuration.count() * 3}}, - kNormalTargetDuration)); - - const WorkDurationFeatures expected = {.averageDuration = kNormalTargetDuration * 2, - .maxDuration = kNormalTargetDuration * 3, - .numMissedDeadlines = 1, - .numDurations = 2}; - const WorkDurationFeatures actual = processor.GetFeatures(); - ASSERT_EQ(actual, expected); -} - -TEST(WorkDurationProcessorTest, GetFeatures_multipleBatches) { - WorkDurationProcessor processor; - ASSERT_TRUE(processor.ReportWorkDurations( - std::vector<WorkDuration>{ - {.timeStampNanos = 0, .durationNanos = kNormalTargetDuration.count()}, - {.timeStampNanos = 0, .durationNanos = kNormalTargetDuration.count() * 3}}, - kNormalTargetDuration)); - ASSERT_TRUE(processor.ReportWorkDurations( - std::vector<WorkDuration>{ - {.timeStampNanos = 0, .durationNanos = kNormalTargetDuration.count() * 6}, - {.timeStampNanos = 0, .durationNanos = kNormalTargetDuration.count() * 2}}, - kNormalTargetDuration)); - - const WorkDurationFeatures expected = {.averageDuration = kNormalTargetDuration * 3, - .maxDuration = kNormalTargetDuration * 6, - .numMissedDeadlines = 3, - .numDurations = 4}; - const WorkDurationFeatures actual = processor.GetFeatures(); - ASSERT_EQ(actual, expected); -} - -TEST(WorkDurationProcessorTest, GetFeatures_scalesDifferentTargetDurations) { - WorkDurationProcessor processor; - ASSERT_TRUE(processor.ReportWorkDurations( - std::vector<WorkDuration>{ - {.timeStampNanos = 0, .durationNanos = kNormalTargetDuration.count() * 2}, - {.timeStampNanos = 0, .durationNanos = kNormalTargetDuration.count() * 6}}, - kNormalTargetDuration * 2)); - - const WorkDurationFeatures expected = {.averageDuration = kNormalTargetDuration * 2, - .maxDuration = kNormalTargetDuration * 3, - .numMissedDeadlines = 1, - .numDurations = 2}; - const WorkDurationFeatures actual = processor.GetFeatures(); - ASSERT_EQ(actual, expected); -} - -TEST(WorkDurationProcessorTest, GetFeatures_noFrames) { - WorkDurationProcessor processor; - const WorkDurationFeatures expected = { - .averageDuration = 0ns, .maxDuration = 0ns, .numMissedDeadlines = 0, .numDurations = 0}; - const WorkDurationFeatures actual = processor.GetFeatures(); - ASSERT_EQ(actual, expected); -} - -TEST(WorkDurationProcessorTest, HasWorkDurations) { - WorkDurationProcessor processor; - ASSERT_FALSE(processor.HasWorkDurations()); - ASSERT_TRUE(processor.ReportWorkDurations( - std::vector<WorkDuration>{ - {.timeStampNanos = 0, .durationNanos = kNormalTargetDuration.count()}}, - kNormalTargetDuration * 2)); - ASSERT_TRUE(processor.HasWorkDurations()); - processor.GetFeatures(); - ASSERT_FALSE(processor.HasWorkDurations()); -} - -TEST(WorkDurationProcessorTest, GetFeatures_tooManyUnprocessedThenClears) { - WorkDurationProcessor processor; - for (int i = 0; i < 1000; i++) { - ASSERT_TRUE(processor.ReportWorkDurations( - std::vector<WorkDuration>{ - {.timeStampNanos = 0, .durationNanos = kNormalTargetDuration.count()}}, - kNormalTargetDuration)); - } - ASSERT_FALSE(processor.ReportWorkDurations( - std::vector<WorkDuration>{ - {.timeStampNanos = 0, .durationNanos = kNormalTargetDuration.count()}}, - kNormalTargetDuration)); - ASSERT_EQ(processor.GetFeatures().numDurations, 0); -} - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/adaptivecpu/tests/mocks.h b/power-libperfmgr/adaptivecpu/tests/mocks.h deleted file mode 100644 index c7a4983b..00000000 --- a/power-libperfmgr/adaptivecpu/tests/mocks.h +++ /dev/null @@ -1,53 +0,0 @@ -/* - * 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. - */ - -#include <gmock/gmock.h> - -#include "adaptivecpu/IFilesystem.h" -#include "adaptivecpu/ITimeSource.h" - -namespace aidl { -namespace google { -namespace hardware { -namespace power { -namespace impl { -namespace pixel { - -class MockFilesystem : public IFilesystem { - public: - ~MockFilesystem() override {} - MOCK_METHOD(bool, ListDirectory, (const std::string &path, std::vector<std::string> *result), - (const, override)); - MOCK_METHOD(bool, ReadFileStream, - (const std::string &path, std::unique_ptr<std::istream> *result), - (const, override)); - MOCK_METHOD(bool, ResetFileStream, (const std::unique_ptr<std::istream> &fileStream), - (const, override)); -}; - -class MockTimeSource : public ITimeSource { - public: - ~MockTimeSource() override {} - MOCK_METHOD(std::chrono::nanoseconds, GetTime, (), (const, override)); - MOCK_METHOD(std::chrono::nanoseconds, GetKernelTime, (), (const, override)); -}; - -} // namespace pixel -} // namespace impl -} // namespace power -} // namespace hardware -} // namespace google -} // namespace aidl diff --git a/power-libperfmgr/aidl/Power.cpp b/power-libperfmgr/aidl/Power.cpp index 5bd18d33..382a7b77 100644 --- a/power-libperfmgr/aidl/Power.cpp +++ b/power-libperfmgr/aidl/Power.cpp @@ -46,9 +46,8 @@ constexpr char kPowerHalStateProp[] = "vendor.powerhal.state"; constexpr char kPowerHalAudioProp[] = "vendor.powerhal.audio"; constexpr char kPowerHalRenderingProp[] = "vendor.powerhal.rendering"; -Power::Power(std::shared_ptr<DisplayLowPower> dlpw, std::shared_ptr<AdaptiveCpu> adaptiveCpu) +Power::Power(std::shared_ptr<DisplayLowPower> dlpw) : mDisplayLowPower(dlpw), - mAdaptiveCpu(adaptiveCpu), mInteractionHandler(nullptr), mVRModeOn(false), mSustainedPerfModeOn(false) { @@ -251,7 +250,6 @@ binder_status_t Power::dump(int fd, const char **, uint32_t) { // Dump nodes through libperfmgr HintManager::GetInstance()->DumpToFd(fd); PowerSessionManager::getInstance()->dumpToFd(fd); - mAdaptiveCpu->DumpToFd(fd); if (!::android::base::WriteStringToFd(buf, fd)) { PLOG(ERROR) << "Failed to dump state to fd"; } @@ -273,8 +271,8 @@ ndk::ScopedAStatus Power::createHintSession(int32_t tgid, int32_t uid, *_aidl_return = nullptr; return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } - std::shared_ptr<IPowerHintSession> session = ndk::SharedRefBase::make<PowerHintSession>( - mAdaptiveCpu, tgid, uid, threadIds, durationNanos); + std::shared_ptr<IPowerHintSession> session = + ndk::SharedRefBase::make<PowerHintSession>(tgid, uid, threadIds, durationNanos); *_aidl_return = session; return ndk::ScopedAStatus::ok(); } diff --git a/power-libperfmgr/aidl/Power.h b/power-libperfmgr/aidl/Power.h index caab993e..b7fd8f26 100644 --- a/power-libperfmgr/aidl/Power.h +++ b/power-libperfmgr/aidl/Power.h @@ -22,7 +22,6 @@ #include <memory> #include <thread> -#include "adaptivecpu/AdaptiveCpu.h" #include "disp-power/DisplayLowPower.h" #include "disp-power/InteractionHandler.h" @@ -39,7 +38,7 @@ using ::aidl::android::hardware::power::Mode; class Power : public ::aidl::android::hardware::power::BnPower { public: - Power(std::shared_ptr<DisplayLowPower> dlpw, std::shared_ptr<AdaptiveCpu> adaptiveCpu); + Power(std::shared_ptr<DisplayLowPower> dlpw); ndk::ScopedAStatus setMode(Mode type, bool enabled) override; ndk::ScopedAStatus isModeSupported(Mode type, bool *_aidl_return) override; ndk::ScopedAStatus setBoost(Boost type, int32_t durationMs) override; @@ -53,7 +52,6 @@ class Power : public ::aidl::android::hardware::power::BnPower { private: std::shared_ptr<DisplayLowPower> mDisplayLowPower; - std::shared_ptr<AdaptiveCpu> mAdaptiveCpu; std::unique_ptr<InteractionHandler> mInteractionHandler; std::atomic<bool> mVRModeOn; std::atomic<bool> mSustainedPerfModeOn; diff --git a/power-libperfmgr/aidl/PowerExt.cpp b/power-libperfmgr/aidl/PowerExt.cpp index 1d91d9b2..f6cd084d 100644 --- a/power-libperfmgr/aidl/PowerExt.cpp +++ b/power-libperfmgr/aidl/PowerExt.cpp @@ -52,11 +52,6 @@ ndk::ScopedAStatus PowerExt::setMode(const std::string &mode, bool enabled) { PowerSessionManager::getInstance()->updateHintMode(mode, enabled); } - if (mode == AdaptiveCpu::HINT_NAME) { - LOG(DEBUG) << "AdaptiveCpu intercepted hint"; - mAdaptiveCpu->HintReceived(enabled); - } - return ndk::ScopedAStatus::ok(); } diff --git a/power-libperfmgr/aidl/PowerExt.h b/power-libperfmgr/aidl/PowerExt.h index e283345c..60552761 100644 --- a/power-libperfmgr/aidl/PowerExt.h +++ b/power-libperfmgr/aidl/PowerExt.h @@ -23,7 +23,6 @@ #include <memory> #include <thread> -#include "adaptivecpu/AdaptiveCpu.h" #include "disp-power/DisplayLowPower.h" namespace aidl { @@ -35,8 +34,7 @@ namespace pixel { class PowerExt : public ::aidl::google::hardware::power::extension::pixel::BnPowerExt { public: - PowerExt(std::shared_ptr<DisplayLowPower> dlpw, std::shared_ptr<AdaptiveCpu> acpu) - : mDisplayLowPower(dlpw), mAdaptiveCpu(acpu) {} + PowerExt(std::shared_ptr<DisplayLowPower> dlpw) : mDisplayLowPower(dlpw) {} ndk::ScopedAStatus setMode(const std::string &mode, bool enabled) override; ndk::ScopedAStatus isModeSupported(const std::string &mode, bool *_aidl_return) override; ndk::ScopedAStatus setBoost(const std::string &boost, int32_t durationMs) override; @@ -44,7 +42,6 @@ class PowerExt : public ::aidl::google::hardware::power::extension::pixel::BnPow private: std::shared_ptr<DisplayLowPower> mDisplayLowPower; - std::shared_ptr<AdaptiveCpu> mAdaptiveCpu; }; } // namespace pixel diff --git a/power-libperfmgr/aidl/PowerHintSession.cpp b/power-libperfmgr/aidl/PowerHintSession.cpp index cac641a6..eadc4cf3 100644 --- a/power-libperfmgr/aidl/PowerHintSession.cpp +++ b/power-libperfmgr/aidl/PowerHintSession.cpp @@ -52,11 +52,14 @@ static inline int64_t ns_to_100us(int64_t ns) { return ns / 100000; } -static int64_t convertWorkDurationToBoostByPid(std::shared_ptr<AdpfConfig> adpfConfig, - nanoseconds targetDuration, - const std::vector<WorkDuration> &actualDurations, - int64_t *integral_error, int64_t *previous_error, - const std::string &idstr) { +} // namespace + +int64_t PowerHintSession::convertWorkDurationToBoostByPid( + const std::vector<WorkDuration> &actualDurations) { + std::shared_ptr<AdpfConfig> adpfConfig = HintManager::GetInstance()->GetAdpfProfile(); + const nanoseconds &targetDuration = mDescriptor->duration; + int64_t &integral_error = mDescriptor->integral_error; + int64_t &previous_error = mDescriptor->previous_error; uint64_t samplingWindowP = adpfConfig->mSamplingWindowP; uint64_t samplingWindowI = adpfConfig->mSamplingWindowI; uint64_t samplingWindowD = adpfConfig->mSamplingWindowD; @@ -80,74 +83,56 @@ static int64_t convertWorkDurationToBoostByPid(std::shared_ptr<AdpfConfig> adpfC // PID control algorithm int64_t error = ns_to_100us(actualDurationNanos - targetDurationNanos); if (i >= d_start) { - derivative_sum += error - (*previous_error); + derivative_sum += error - previous_error; } if (i >= p_start) { err_sum += error; } if (i >= i_start) { - *integral_error = *integral_error + error * dt; - *integral_error = std::min(adpfConfig->getPidIHighDivI(), *integral_error); - *integral_error = std::max(adpfConfig->getPidILowDivI(), *integral_error); + integral_error += error * dt; + integral_error = std::min(adpfConfig->getPidIHighDivI(), integral_error); + integral_error = std::max(adpfConfig->getPidILowDivI(), integral_error); } - *previous_error = error; + previous_error = error; } int64_t pOut = static_cast<int64_t>((err_sum > 0 ? adpfConfig->mPidPo : adpfConfig->mPidPu) * err_sum / (length - p_start)); - int64_t iOut = static_cast<int64_t>(adpfConfig->mPidI * (*integral_error)); + int64_t iOut = static_cast<int64_t>(adpfConfig->mPidI * integral_error); int64_t dOut = static_cast<int64_t>((derivative_sum > 0 ? adpfConfig->mPidDo : adpfConfig->mPidDu) * derivative_sum / dt / (length - d_start)); int64_t output = pOut + iOut + dOut; if (ATRACE_ENABLED()) { - std::string sz = StringPrintf("adpf.%s-pid.err", idstr.c_str()); - ATRACE_INT(sz.c_str(), err_sum / (length - p_start)); - sz = StringPrintf("adpf.%s-pid.integral", idstr.c_str()); - ATRACE_INT(sz.c_str(), *integral_error); - sz = StringPrintf("adpf.%s-pid.derivative", idstr.c_str()); - ATRACE_INT(sz.c_str(), derivative_sum / dt / (length - d_start)); - sz = StringPrintf("adpf.%s-pid.pOut", idstr.c_str()); - ATRACE_INT(sz.c_str(), pOut); - sz = StringPrintf("adpf.%s-pid.iOut", idstr.c_str()); - ATRACE_INT(sz.c_str(), iOut); - sz = StringPrintf("adpf.%s-pid.dOut", idstr.c_str()); - ATRACE_INT(sz.c_str(), dOut); - sz = StringPrintf("adpf.%s-pid.output", idstr.c_str()); - ATRACE_INT(sz.c_str(), output); + traceSessionVal("pid.err", err_sum / (length - p_start)); + traceSessionVal("pid.integral", integral_error); + traceSessionVal("pid.derivative", derivative_sum / dt / (length - d_start)); + traceSessionVal("pid.pOut", pOut); + traceSessionVal("pid.iOut", iOut); + traceSessionVal("pid.dOut", dOut); + traceSessionVal("pid.output", output); } return output; } -} // namespace - -PowerHintSession::PowerHintSession(std::shared_ptr<AdaptiveCpu> adaptiveCpu, int32_t tgid, - int32_t uid, const std::vector<int32_t> &threadIds, +PowerHintSession::PowerHintSession(int32_t tgid, int32_t uid, const std::vector<int32_t> &threadIds, int64_t durationNanos) - : mAdaptiveCpu(adaptiveCpu) { + : mStaleTimerHandler(sp<StaleTimerHandler>::make(this)), + mBoostTimerHandler(sp<BoostTimerHandler>::make(this)) { mDescriptor = new AppHintDesc(tgid, uid, threadIds); mDescriptor->duration = std::chrono::nanoseconds(durationNanos); - mStaleTimerHandler = sp<StaleTimerHandler>(new StaleTimerHandler(this)); - mEarlyBoostHandler = sp<EarlyBoostHandler>(new EarlyBoostHandler(this)); + mIdString = StringPrintf("%" PRId32 "-%" PRId32 "-%" PRIxPTR, mDescriptor->tgid, + mDescriptor->uid, reinterpret_cast<uintptr_t>(this) & 0xffff); + mPowerManagerHandler = PowerSessionManager::getInstance(); mLastUpdatedTime.store(std::chrono::steady_clock::now()); - mLastStartedTimeNs = - std::chrono::duration_cast<std::chrono::nanoseconds>( - (std::chrono::steady_clock::now() - mDescriptor->duration).time_since_epoch()) - .count(); - mLastDurationNs = durationNanos; - mWorkPeriodNs = durationNanos; - if (ATRACE_ENABLED()) { - const std::string idstr = getIdString(); - std::string sz = StringPrintf("adpf.%s-target", idstr.c_str()); - ATRACE_INT(sz.c_str(), (int64_t)mDescriptor->duration.count()); - sz = StringPrintf("adpf.%s-active", idstr.c_str()); - ATRACE_INT(sz.c_str(), mDescriptor->is_active.load()); + traceSessionVal("target", mDescriptor->duration.count()); + traceSessionVal("active", mDescriptor->is_active.load()); } PowerSessionManager::getInstance()->addPowerSession(this); // init boost - setSessionUclampMin(HintManager::GetInstance()->GetAdpfProfile()->mUclampMinInit); + sendHint(SessionHint::CPU_LOAD_RESET); ALOGV("PowerHintSession created: %s", mDescriptor->toString().c_str()); } @@ -155,21 +140,15 @@ PowerHintSession::~PowerHintSession() { close(); ALOGV("PowerHintSession deleted: %s", mDescriptor->toString().c_str()); if (ATRACE_ENABLED()) { - const std::string idstr = getIdString(); - std::string sz = StringPrintf("adpf.%s-target", idstr.c_str()); - ATRACE_INT(sz.c_str(), 0); - sz = StringPrintf("adpf.%s-actl_last", idstr.c_str()); - ATRACE_INT(sz.c_str(), 0); - sz = sz = StringPrintf("adpf.%s-active", idstr.c_str()); - ATRACE_INT(sz.c_str(), 0); + traceSessionVal("target", 0); + traceSessionVal("actl_last", 0); + traceSessionVal("active", 0); } delete mDescriptor; } -std::string PowerHintSession::getIdString() const { - std::string idstr = StringPrintf("%" PRId32 "-%" PRId32 "-%" PRIxPTR, mDescriptor->tgid, - mDescriptor->uid, reinterpret_cast<uintptr_t>(this) & 0xffff); - return idstr; +void PowerHintSession::traceSessionVal(char const *identifier, int64_t val) const { + ATRACE_INT(StringPrintf("adpf.%s-%s", mIdString.c_str(), identifier).c_str(), val); } bool PowerHintSession::isAppSession() { @@ -182,7 +161,7 @@ void PowerHintSession::updateUniveralBoostMode() { return; } if (ATRACE_ENABLED()) { - const std::string tag = StringPrintf("%s:updateUniveralBoostMode()", getIdString().c_str()); + const std::string tag = StringPrintf("%s:updateUniveralBoostMode()", mIdString.c_str()); ATRACE_BEGIN(tag.c_str()); } PowerHintMonitor::getInstance()->getLooper()->sendMessage(mPowerManagerHandler, NULL); @@ -191,20 +170,27 @@ void PowerHintSession::updateUniveralBoostMode() { } } -int PowerHintSession::setSessionUclampMin(int32_t min) { +void PowerHintSession::tryToSendPowerHint(std::string hint) { + if (!mSupportedHints[hint].has_value()) { + mSupportedHints[hint] = HintManager::GetInstance()->IsHintSupported(hint); + } + if (mSupportedHints[hint].value()) { + HintManager::GetInstance()->DoHint(hint); + } +} + +int PowerHintSession::setSessionUclampMin(int32_t min, bool resetStale) { { std::lock_guard<std::mutex> guard(mSessionLock); mDescriptor->current_min = min; } - if (min) { + if (min != 0 && resetStale) { mStaleTimerHandler->updateTimer(); } PowerSessionManager::getInstance()->setUclampMin(this, min); if (ATRACE_ENABLED()) { - const std::string idstr = getIdString(); - std::string sz = StringPrintf("adpf.%s-min", idstr.c_str()); - ATRACE_INT(sz.c_str(), min); + traceSessionVal("min", min); } return 0; } @@ -214,9 +200,9 @@ int PowerHintSession::getUclampMin() { } void PowerHintSession::dumpToStream(std::ostream &stream) { - stream << "ID.Min.Act.Timeout(" << getIdString(); + stream << "ID.Min.Act.Timeout(" << mIdString; stream << ", " << mDescriptor->current_min; - stream << ", " << mDescriptor->is_active; + stream << ", " << mDescriptor->is_active.load(); stream << ", " << isTimeout() << ")"; } @@ -231,11 +217,10 @@ ndk::ScopedAStatus PowerHintSession::pause() { mDescriptor->is_active.store(false); setStale(); if (ATRACE_ENABLED()) { - const std::string idstr = getIdString(); - std::string sz = StringPrintf("adpf.%s-active", idstr.c_str()); - ATRACE_INT(sz.c_str(), mDescriptor->is_active.load()); + traceSessionVal("active", mDescriptor->is_active.load()); } updateUniveralBoostMode(); + PowerSessionManager::getInstance()->removeThreadsFromPowerSession(this); return ndk::ScopedAStatus::ok(); } @@ -247,12 +232,11 @@ ndk::ScopedAStatus PowerHintSession::resume() { if (mDescriptor->is_active.load()) return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); mDescriptor->is_active.store(true); + PowerSessionManager::getInstance()->addThreadsFromPowerSession(this); // resume boost setSessionUclampMin(mDescriptor->current_min); if (ATRACE_ENABLED()) { - const std::string idstr = getIdString(); - std::string sz = StringPrintf("adpf.%s-active", idstr.c_str()); - ATRACE_INT(sz.c_str(), mDescriptor->is_active.load()); + traceSessionVal("active", mDescriptor->is_active.load()); } updateUniveralBoostMode(); return ndk::ScopedAStatus::ok(); @@ -265,14 +249,10 @@ ndk::ScopedAStatus PowerHintSession::close() { } // Remove the session from PowerSessionManager first to avoid racing. PowerSessionManager::getInstance()->removePowerSession(this); + mStaleTimerHandler->setSessionDead(); + mBoostTimerHandler->setSessionDead(); setSessionUclampMin(0); - { - std::lock_guard<std::mutex> guard(mSessionLock); - mSessionClosed.store(true); - } mDescriptor->is_active.store(false); - mEarlyBoostHandler->setSessionDead(); - mStaleTimerHandler->setSessionDead(); updateUniveralBoostMode(); return ndk::ScopedAStatus::ok(); } @@ -292,9 +272,7 @@ ndk::ScopedAStatus PowerHintSession::updateTargetWorkDuration(int64_t targetDura mDescriptor->duration = std::chrono::nanoseconds(targetDurationNanos); if (ATRACE_ENABLED()) { - const std::string idstr = getIdString(); - std::string sz = StringPrintf("adpf.%s-target", idstr.c_str()); - ATRACE_INT(sz.c_str(), (int64_t)mDescriptor->duration.count()); + traceSessionVal("target", mDescriptor->duration.count()); } return ndk::ScopedAStatus::ok(); @@ -322,46 +300,95 @@ ndk::ScopedAStatus PowerHintSession::reportActualWorkDuration( mDescriptor->update_count++; bool isFirstFrame = isTimeout(); if (ATRACE_ENABLED()) { - const std::string idstr = getIdString(); - std::string sz = StringPrintf("adpf.%s-batch_size", idstr.c_str()); - ATRACE_INT(sz.c_str(), actualDurations.size()); - sz = StringPrintf("adpf.%s-actl_last", idstr.c_str()); - ATRACE_INT(sz.c_str(), actualDurations.back().durationNanos); - sz = StringPrintf("adpf.%s-target", idstr.c_str()); - ATRACE_INT(sz.c_str(), (int64_t)mDescriptor->duration.count()); - sz = StringPrintf("adpf.%s-hint.count", idstr.c_str()); - ATRACE_INT(sz.c_str(), mDescriptor->update_count); - sz = StringPrintf("adpf.%s-hint.overtime", idstr.c_str()); - ATRACE_INT(sz.c_str(), - actualDurations.back().durationNanos - mDescriptor->duration.count() > 0); + traceSessionVal("batch_size", actualDurations.size()); + traceSessionVal("actl_last", actualDurations.back().durationNanos); + traceSessionVal("target", mDescriptor->duration.count()); + traceSessionVal("hint.count", mDescriptor->update_count); + traceSessionVal("hint.overtime", + actualDurations.back().durationNanos - mDescriptor->duration.count() > 0); } mLastUpdatedTime.store(std::chrono::steady_clock::now()); if (isFirstFrame) { + if (isAppSession()) { + tryToSendPowerHint("ADPF_FIRST_FRAME"); + } updateUniveralBoostMode(); } + disableTemporaryBoost(); + if (!adpfConfig->mPidOn) { setSessionUclampMin(adpfConfig->mUclampMinHigh); return ndk::ScopedAStatus::ok(); } - int64_t output = convertWorkDurationToBoostByPid( - adpfConfig, mDescriptor->duration, actualDurations, &(mDescriptor->integral_error), - &(mDescriptor->previous_error), getIdString()); + + int64_t output = convertWorkDurationToBoostByPid(actualDurations); /* apply to all the threads in the group */ int next_min = std::min(static_cast<int>(adpfConfig->mUclampMinHigh), mDescriptor->current_min + static_cast<int>(output)); next_min = std::max(static_cast<int>(adpfConfig->mUclampMinLow), next_min); setSessionUclampMin(next_min); - mStaleTimerHandler->updateTimer(getStaleTime()); - if (HintManager::GetInstance()->GetAdpfProfile()->mEarlyBoostOn) { - updateWorkPeriod(actualDurations); - mEarlyBoostHandler->updateTimer(getEarlyBoostTime()); + + return ndk::ScopedAStatus::ok(); +} + +ndk::ScopedAStatus PowerHintSession::sendHint(SessionHint hint) { + if (mSessionClosed) { + ALOGE("Error: session is dead"); + return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); + } + disableTemporaryBoost(); + std::shared_ptr<AdpfConfig> adpfConfig = HintManager::GetInstance()->GetAdpfProfile(); + switch (hint) { + case SessionHint::CPU_LOAD_UP: + mNextUclampMin.store(mDescriptor->current_min); + mBoostTimerHandler->updateTimer(mDescriptor->duration * 2); + setSessionUclampMin(adpfConfig->mUclampMinHigh); + break; + case SessionHint::CPU_LOAD_DOWN: + setSessionUclampMin(adpfConfig->mUclampMinLow); + break; + case SessionHint::CPU_LOAD_RESET: + mNextUclampMin.store(std::max(adpfConfig->mUclampMinInit, + static_cast<uint32_t>(mDescriptor->current_min))); + mBoostTimerHandler->updateTimer(duration_cast<nanoseconds>( + mDescriptor->duration * adpfConfig->mStaleTimeFactor / 2.0)); + setSessionUclampMin(adpfConfig->mUclampMinHigh); + break; + case SessionHint::CPU_LOAD_RESUME: + setSessionUclampMin(mDescriptor->current_min); + break; + default: + ALOGE("Error: hint is invalid"); + return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); + } + tryToSendPowerHint(toString(hint)); + mLastUpdatedTime.store(std::chrono::steady_clock::now()); + if (ATRACE_ENABLED()) { + mLastHintSent = static_cast<int>(hint); + traceSessionVal("session_hint", static_cast<int>(hint)); } + return ndk::ScopedAStatus::ok(); +} - mAdaptiveCpu->ReportWorkDurations(actualDurations, mDescriptor->duration); +ndk::ScopedAStatus PowerHintSession::setThreads(const std::vector<int32_t> &threadIds) { + if (mSessionClosed) { + ALOGE("Error: session is dead"); + return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); + } + if (threadIds.size() == 0) { + LOG(ERROR) << "Error: threadIds.size() shouldn't be " << threadIds.size(); + return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); + } + PowerSessionManager::getInstance()->removeThreadsFromPowerSession(this); + mDescriptor->threadIds.resize(threadIds.size()); + std::copy(threadIds.begin(), threadIds.end(), back_inserter(mDescriptor->threadIds)); + PowerSessionManager::getInstance()->addThreadsFromPowerSession(this); + // init boost + setSessionUclampMin(HintManager::GetInstance()->GetAdpfProfile()->mUclampMinInit); return ndk::ScopedAStatus::ok(); } @@ -392,200 +419,106 @@ bool PowerHintSession::isActive() { bool PowerHintSession::isTimeout() { auto now = std::chrono::steady_clock::now(); - return now >= getStaleTime(); + time_point<steady_clock> staleTime = + mLastUpdatedTime.load() + + nanoseconds(static_cast<int64_t>( + mDescriptor->duration.count() * + HintManager::GetInstance()->GetAdpfProfile()->mStaleTimeFactor)); + return now >= staleTime; } -const std::vector<int> &PowerHintSession::getTidList() const { +const std::vector<int32_t> &PowerHintSession::getTidList() const { return mDescriptor->threadIds; } -void PowerHintSession::setStale() { - // Reset to default uclamp value. - PowerSessionManager::getInstance()->setUclampMin(this, 0); - // Deliver a task to check if all sessions are inactive. - updateUniveralBoostMode(); +bool PowerHintSession::disableTemporaryBoost() { if (ATRACE_ENABLED()) { - const std::string idstr = getIdString(); - std::string sz = StringPrintf("adpf.%s-min", idstr.c_str()); - ATRACE_INT(sz.c_str(), 0); + if (mLastHintSent != -1) { + mLastHintSent = -1; + traceSessionVal("session_hint", -1); + } } -} - -void PowerHintSession::wakeup() { - std::lock_guard<std::mutex> guard(mSessionLock); - // We only wake up non-paused and stale sessions - if (mSessionClosed || !isActive() || !isTimeout()) - return; - if (ATRACE_ENABLED()) { - std::string tag = StringPrintf("wakeup.%s(a:%d,s:%d)", getIdString().c_str(), isActive(), - isTimeout()); - ATRACE_NAME(tag.c_str()); + // replace temporary uclamp_min value with true min + std::optional<int> trueMin = mNextUclampMin.load(); + if (trueMin.has_value()) { + std::lock_guard<std::mutex> guard(mSessionLock); + mDescriptor->current_min = *trueMin; + mNextUclampMin.store(std::nullopt); + return true; } - std::shared_ptr<AdpfConfig> adpfConfig = HintManager::GetInstance()->GetAdpfProfile(); - int min = std::max(mDescriptor->current_min, static_cast<int>(adpfConfig->mUclampMinInit)); - mDescriptor->current_min = min; - PowerSessionManager::getInstance()->setUclampMinLocked(this, min); - mStaleTimerHandler->updateTimer(); - if (ATRACE_ENABLED()) { - const std::string idstr = getIdString(); - std::string sz = StringPrintf("adpf.%s-min", idstr.c_str()); - ATRACE_INT(sz.c_str(), min); - } + return false; } -void PowerHintSession::updateWorkPeriod(const std::vector<WorkDuration> &actualDurations) { - if (actualDurations.size() == 0) - return; - if (actualDurations.size() >= 2) { - const WorkDuration &last = actualDurations[actualDurations.size() - 2]; - mLastStartedTimeNs = last.timeStampNanos - last.durationNanos; - } - const WorkDuration ¤t = actualDurations.back(); - int64_t curr_start = current.timeStampNanos - current.durationNanos; - int64_t period = curr_start - mLastStartedTimeNs; - if (period > 0 && period < mDescriptor->duration.count() * 2) { - // Accounting workload period with moving average for the last 10 workload. - mWorkPeriodNs = 0.9 * mWorkPeriodNs + 0.1 * period; - if (ATRACE_ENABLED()) { - const std::string idstr = getIdString(); - std::string sz = StringPrintf("adpf.%s-timer.period", idstr.c_str()); - ATRACE_INT(sz.c_str(), mWorkPeriodNs); - } +void PowerHintSession::setStale() { + // Make sure any temporary boost is disabled + disableTemporaryBoost(); + // Reset to default uclamp value. + PowerSessionManager::getInstance()->setUclampMin(this, 0); + // Deliver a task to check if all sessions are inactive. + updateUniveralBoostMode(); + if (ATRACE_ENABLED()) { + traceSessionVal("min", 0); } - mLastStartedTimeNs = curr_start; - mLastDurationNs = current.durationNanos; -} - -time_point<steady_clock> PowerHintSession::getEarlyBoostTime() { - std::shared_ptr<AdpfConfig> adpfConfig = HintManager::GetInstance()->GetAdpfProfile(); - int64_t earlyBoostTimeoutNs = - (int64_t)mDescriptor->duration.count() * adpfConfig->mEarlyBoostTimeFactor; - time_point<steady_clock> nextStartTime = - mLastUpdatedTime.load() + nanoseconds(mWorkPeriodNs - mLastDurationNs); - return nextStartTime + nanoseconds(earlyBoostTimeoutNs); -} - -time_point<steady_clock> PowerHintSession::getStaleTime() { - return mLastUpdatedTime.load() + - nanoseconds(static_cast<int64_t>( - mDescriptor->duration.count() * - HintManager::GetInstance()->GetAdpfProfile()->mStaleTimeFactor)); } -void PowerHintSession::StaleTimerHandler::updateTimer() { - time_point<steady_clock> staleTime = - std::chrono::steady_clock::now() + - nanoseconds(static_cast<int64_t>( - mSession->mDescriptor->duration.count() * - HintManager::GetInstance()->GetAdpfProfile()->mStaleTimeFactor)); - updateTimer(staleTime); -} - -void PowerHintSession::StaleTimerHandler::updateTimer(time_point<steady_clock> staleTime) { - mStaleTime.store(staleTime); +void PowerHintSession::SessionTimerHandler::updateTimer(nanoseconds delay) { + mTimeout.store(steady_clock::now() + delay); { std::lock_guard<std::mutex> guard(mMessageLock); - PowerHintMonitor::getInstance()->getLooper()->removeMessages(mSession->mStaleTimerHandler); - PowerHintMonitor::getInstance()->getLooper()->sendMessage(mSession->mStaleTimerHandler, - NULL); + sp<MessageHandler> selfPtr = sp<MessageHandler>::fromExisting(this); + PowerHintMonitor::getInstance()->getLooper()->removeMessages(selfPtr); + PowerHintMonitor::getInstance()->getLooper()->sendMessageDelayed(delay.count(), selfPtr, + NULL); } - mIsMonitoring.store(true); if (ATRACE_ENABLED()) { - const std::string idstr = mSession->getIdString(); - std::string sz = StringPrintf("adpf.%s-timer.stale", idstr.c_str()); - ATRACE_INT(sz.c_str(), 0); + mSession->traceSessionVal(("timer." + mName).c_str(), 0); } } -void PowerHintSession::StaleTimerHandler::handleMessage(const Message &) { +void PowerHintSession::SessionTimerHandler::handleMessage(const Message &) { + std::lock_guard<std::mutex> guard(mClosedLock); if (mIsSessionDead) { return; } - auto now = std::chrono::steady_clock::now(); - int64_t next = - static_cast<int64_t>(duration_cast<nanoseconds>(mStaleTime.load() - now).count()); + time_point now = steady_clock::now(); + int64_t next = (mTimeout.load() - now).count(); if (next > 0) { // Schedule for the stale timeout check. std::lock_guard<std::mutex> guard(mMessageLock); - PowerHintMonitor::getInstance()->getLooper()->removeMessages(mSession->mStaleTimerHandler); - PowerHintMonitor::getInstance()->getLooper()->sendMessageDelayed( - next, mSession->mStaleTimerHandler, NULL); + sp<MessageHandler> selfPtr = sp<MessageHandler>::fromExisting(this); + PowerHintMonitor::getInstance()->getLooper()->removeMessages(selfPtr); + PowerHintMonitor::getInstance()->getLooper()->sendMessageDelayed(next, selfPtr, NULL); } else { - mSession->setStale(); - mIsMonitoring.store(false); - if (ATRACE_ENABLED()) { - const std::string idstr = mSession->getIdString(); - std::string sz = StringPrintf("adpf.%s-timer.earlyboost", idstr.c_str()); - ATRACE_INT(sz.c_str(), 0); - } + onTimeout(); } if (ATRACE_ENABLED()) { - const std::string idstr = mSession->getIdString(); - std::string sz = StringPrintf("adpf.%s-timer.stale", idstr.c_str()); - ATRACE_INT(sz.c_str(), mIsMonitoring ? 0 : 1); + mSession->traceSessionVal(("timer." + mName).c_str(), next > 0 ? 0 : 1); } } -void PowerHintSession::StaleTimerHandler::setSessionDead() { - std::lock_guard<std::mutex> guard(mStaleLock); +void PowerHintSession::SessionTimerHandler::setSessionDead() { + std::lock_guard<std::mutex> guard(mClosedLock); mIsSessionDead = true; - PowerHintMonitor::getInstance()->getLooper()->removeMessages(mSession->mStaleTimerHandler); + PowerHintMonitor::getInstance()->getLooper()->removeMessages( + sp<MessageHandler>::fromExisting(this)); } -void PowerHintSession::EarlyBoostHandler::updateTimer(time_point<steady_clock> boostTime) { - mBoostTime.store(boostTime); - { - std::lock_guard<std::mutex> guard(mMessageLock); - PowerHintMonitor::getInstance()->getLooper()->removeMessages(mSession->mEarlyBoostHandler); - PowerHintMonitor::getInstance()->getLooper()->sendMessage(mSession->mEarlyBoostHandler, - NULL); - } - mIsMonitoring.store(true); - if (ATRACE_ENABLED()) { - const std::string idstr = mSession->getIdString(); - std::string sz = StringPrintf("adpf.%s-timer.earlyboost", idstr.c_str()); - ATRACE_INT(sz.c_str(), 1); - } +void PowerHintSession::StaleTimerHandler::updateTimer() { + SessionTimerHandler::updateTimer(duration_cast<nanoseconds>( + mSession->mDescriptor->duration * + HintManager::GetInstance()->GetAdpfProfile()->mStaleTimeFactor)); } -void PowerHintSession::EarlyBoostHandler::handleMessage(const Message &) { - std::lock_guard<std::mutex> guard(mBoostLock); - if (mIsSessionDead) { - return; - } - auto now = std::chrono::steady_clock::now(); - int64_t next = - static_cast<int64_t>(duration_cast<nanoseconds>(mBoostTime.load() - now).count()); - if (next > 0) { - if (ATRACE_ENABLED()) { - const std::string idstr = mSession->getIdString(); - std::string sz = StringPrintf("adpf.%s-timer.earlyboost", idstr.c_str()); - ATRACE_INT(sz.c_str(), 1); - } - std::lock_guard<std::mutex> guard(mMessageLock); - PowerHintMonitor::getInstance()->getLooper()->removeMessages(mSession->mEarlyBoostHandler); - PowerHintMonitor::getInstance()->getLooper()->sendMessageDelayed( - next, mSession->mEarlyBoostHandler, NULL); - } else { - std::shared_ptr<AdpfConfig> adpfConfig = HintManager::GetInstance()->GetAdpfProfile(); - PowerSessionManager::getInstance()->setUclampMin(mSession, adpfConfig->mUclampMinHigh); - mIsMonitoring.store(false); - if (ATRACE_ENABLED()) { - const std::string idstr = mSession->getIdString(); - std::string sz = StringPrintf("adpf.%s-min", idstr.c_str()); - ATRACE_INT(sz.c_str(), adpfConfig->mUclampMinHigh); - sz = StringPrintf("adpf.%s-timer.earlyboost", idstr.c_str()); - ATRACE_INT(sz.c_str(), 2); - } - } +void PowerHintSession::StaleTimerHandler::onTimeout() { + mSession->setStale(); } -void PowerHintSession::EarlyBoostHandler::setSessionDead() { - std::lock_guard<std::mutex> guard(mBoostLock); - mIsSessionDead = true; - PowerHintMonitor::getInstance()->getLooper()->removeMessages(mSession->mEarlyBoostHandler); +void PowerHintSession::BoostTimerHandler::onTimeout() { + if (mSession->disableTemporaryBoost()) { + mSession->setSessionUclampMin(mSession->getUclampMin(), false); + } } } // namespace pixel diff --git a/power-libperfmgr/aidl/PowerHintSession.h b/power-libperfmgr/aidl/PowerHintSession.h index 96b445ed..e1c2523d 100644 --- a/power-libperfmgr/aidl/PowerHintSession.h +++ b/power-libperfmgr/aidl/PowerHintSession.h @@ -17,6 +17,7 @@ #pragma once #include <aidl/android/hardware/power/BnPowerHintSession.h> +#include <aidl/android/hardware/power/SessionHint.h> #include <aidl/android/hardware/power/WorkDuration.h> #include <utils/Looper.h> #include <utils/Thread.h> @@ -24,8 +25,6 @@ #include <mutex> #include <unordered_map> -#include "adaptivecpu/AdaptiveCpu.h" - namespace aidl { namespace google { namespace hardware { @@ -34,6 +33,7 @@ namespace impl { namespace pixel { using aidl::android::hardware::power::BnPowerHintSession; +using aidl::android::hardware::power::SessionHint; using aidl::android::hardware::power::WorkDuration; using ::android::Message; using ::android::MessageHandler; @@ -44,7 +44,7 @@ using std::chrono::steady_clock; using std::chrono::time_point; struct AppHintDesc { - AppHintDesc(int32_t tgid, int32_t uid, std::vector<int> threadIds) + AppHintDesc(int32_t tgid, int32_t uid, std::vector<int32_t> threadIds) : tgid(tgid), uid(uid), threadIds(std::move(threadIds)), @@ -57,7 +57,7 @@ struct AppHintDesc { std::string toString() const; const int32_t tgid; const int32_t uid; - const std::vector<int> threadIds; + std::vector<int32_t> threadIds; nanoseconds duration; int current_min; // status @@ -70,8 +70,8 @@ struct AppHintDesc { class PowerHintSession : public BnPowerHintSession { public: - explicit PowerHintSession(std::shared_ptr<AdaptiveCpu> adaptiveCpu, int32_t tgid, int32_t uid, - const std::vector<int32_t> &threadIds, int64_t durationNanos); + explicit PowerHintSession(int32_t tgid, int32_t uid, const std::vector<int32_t> &threadIds, + int64_t durationNanos); ~PowerHintSession(); ndk::ScopedAStatus close() override; ndk::ScopedAStatus pause() override; @@ -79,9 +79,10 @@ class PowerHintSession : public BnPowerHintSession { ndk::ScopedAStatus updateTargetWorkDuration(int64_t targetDurationNanos) override; ndk::ScopedAStatus reportActualWorkDuration( const std::vector<WorkDuration> &actualDurations) override; + ndk::ScopedAStatus sendHint(SessionHint hint) override; + ndk::ScopedAStatus setThreads(const std::vector<int32_t> &threadIds) override; bool isActive(); bool isTimeout(); - void wakeup(); void setStale(); // Is this hint session for a user application bool isAppSession(); @@ -89,62 +90,63 @@ class PowerHintSession : public BnPowerHintSession { int getUclampMin(); void dumpToStream(std::ostream &stream); - void updateWorkPeriod(const std::vector<WorkDuration> &actualDurations); - time_point<steady_clock> getEarlyBoostTime(); - time_point<steady_clock> getStaleTime(); + // Disable any temporary boost and return to normal operation. It does not + // reset the actual uclamp value, and relies on the caller to do so, to + // prevent double-setting. Returns true if it actually disabled an active boost + bool disableTemporaryBoost(); private: - class StaleTimerHandler : public MessageHandler { + class SessionTimerHandler : public MessageHandler { public: - StaleTimerHandler(PowerHintSession *session) - : mSession(session), mIsMonitoring(false), mIsSessionDead(false) {} - void updateTimer(); - void updateTimer(time_point<steady_clock> staleTime); + SessionTimerHandler(PowerHintSession *session, std::string name) + : mSession(session), mIsSessionDead(false), mName(name) {} + void updateTimer(nanoseconds delay); void handleMessage(const Message &message) override; void setSessionDead(); + virtual void onTimeout() = 0; - private: + protected: PowerHintSession *mSession; - std::mutex mStaleLock; + std::mutex mClosedLock; std::mutex mMessageLock; - std::atomic<time_point<steady_clock>> mStaleTime; - std::atomic<bool> mIsMonitoring; + std::atomic<time_point<steady_clock>> mTimeout; bool mIsSessionDead; + const std::string mName; }; - class EarlyBoostHandler : public MessageHandler { + class StaleTimerHandler : public SessionTimerHandler { public: - EarlyBoostHandler(PowerHintSession *session) - : mSession(session), mIsMonitoring(false), mIsSessionDead(false) {} - void updateTimer(time_point<steady_clock> boostTime); - void handleMessage(const Message &message) override; - void setSessionDead(); + StaleTimerHandler(PowerHintSession *session) : SessionTimerHandler(session, "stale") {} + void updateTimer(); + void onTimeout() override; + }; - private: - PowerHintSession *mSession; - std::mutex mBoostLock; - std::mutex mMessageLock; - std::atomic<time_point<steady_clock>> mBoostTime; - std::atomic<bool> mIsMonitoring; - bool mIsSessionDead; + class BoostTimerHandler : public SessionTimerHandler { + public: + BoostTimerHandler(PowerHintSession *session) : SessionTimerHandler(session, "boost") {} + void onTimeout() override; }; private: void updateUniveralBoostMode(); - int setSessionUclampMin(int32_t min); - std::string getIdString() const; - const std::shared_ptr<AdaptiveCpu> mAdaptiveCpu; + int setSessionUclampMin(int32_t min, bool resetStale = true); + void tryToSendPowerHint(std::string hint); + int64_t convertWorkDurationToBoostByPid(const std::vector<WorkDuration> &actualDurations); + void traceSessionVal(char const *identifier, int64_t val) const; AppHintDesc *mDescriptor = nullptr; sp<StaleTimerHandler> mStaleTimerHandler; - sp<EarlyBoostHandler> mEarlyBoostHandler; + sp<BoostTimerHandler> mBoostTimerHandler; std::atomic<time_point<steady_clock>> mLastUpdatedTime; sp<MessageHandler> mPowerManagerHandler; std::mutex mSessionLock; std::atomic<bool> mSessionClosed = false; - // These 3 variables are for earlyboost work period estimation. - int64_t mLastStartedTimeNs; - int64_t mLastDurationNs; - int64_t mWorkPeriodNs; + std::string mIdString; + // Used when setting a temporary boost value to hold the true boost + std::atomic<std::optional<int>> mNextUclampMin; + // To cache the status of whether ADPF hints are supported. + std::unordered_map<std::string, std::optional<bool>> mSupportedHints; + // Last session hint sent, used for logging + int mLastHintSent = -1; }; } // namespace pixel diff --git a/power-libperfmgr/aidl/PowerSessionManager.cpp b/power-libperfmgr/aidl/PowerSessionManager.cpp index 516942ac..e66ff5f3 100644 --- a/power-libperfmgr/aidl/PowerSessionManager.cpp +++ b/power-libperfmgr/aidl/PowerSessionManager.cpp @@ -33,6 +33,7 @@ namespace power { namespace impl { namespace pixel { +using ::android::perfmgr::AdpfConfig; using ::android::perfmgr::HintManager; namespace { @@ -96,16 +97,6 @@ void PowerSessionManager::updateHintBoost(const std::string &boost, int32_t dura ATRACE_CALL(); ALOGV("PowerSessionManager::updateHintBoost: boost: %s, durationMs: %d", boost.c_str(), durationMs); - if (boost.compare("DISPLAY_UPDATE_IMMINENT") == 0) { - PowerHintMonitor::getInstance()->getLooper()->sendMessage(mWakeupHandler, NULL); - } -} - -void PowerSessionManager::wakeSessions() { - std::lock_guard<std::mutex> guard(mLock); - for (PowerHintSession *s : mSessions) { - s->wakeup(); - } } int PowerSessionManager::getDisplayRefreshRate() { @@ -114,42 +105,46 @@ int PowerSessionManager::getDisplayRefreshRate() { void PowerSessionManager::addPowerSession(PowerHintSession *session) { std::lock_guard<std::mutex> guard(mLock); + mSessions.insert(session); + addThreadsFromPowerSessionLocked(session); +} + +void PowerSessionManager::removePowerSession(PowerHintSession *session) { + std::lock_guard<std::mutex> guard(mLock); + mSessions.erase(session); + removeThreadsFromPowerSessionLocked(session); +} + +void PowerSessionManager::addThreadsFromPowerSession(PowerHintSession *session) { + std::lock_guard<std::mutex> guard(mLock); + addThreadsFromPowerSessionLocked(session); +} + +void PowerSessionManager::addThreadsFromPowerSessionLocked(PowerHintSession *session) { for (auto t : session->getTidList()) { - mTidSessionListMap[t].insert(session); - if (mTidRefCountMap.find(t) == mTidRefCountMap.end()) { + if (mTidSessionListMap[t].empty()) { if (!SetTaskProfiles(t, {"ResetUclampGrp"})) { ALOGW("Failed to set ResetUclampGrp task profile for tid:%d", t); - } else { - mTidRefCountMap[t] = 1; } - continue; } - if (mTidRefCountMap[t] <= 0) { - ALOGE("Error! Unexpected zero/negative RefCount:%d for tid:%d", mTidRefCountMap[t], t); - continue; - } - mTidRefCountMap[t]++; + mTidSessionListMap[t].insert(session); } - mSessions.insert(session); } -void PowerSessionManager::removePowerSession(PowerHintSession *session) { +void PowerSessionManager::removeThreadsFromPowerSession(PowerHintSession *session) { std::lock_guard<std::mutex> guard(mLock); + removeThreadsFromPowerSessionLocked(session); +} + +void PowerSessionManager::removeThreadsFromPowerSessionLocked(PowerHintSession *session) { for (auto t : session->getTidList()) { - if (mTidRefCountMap.find(t) == mTidRefCountMap.end()) { - ALOGE("Unexpected Error! Failed to look up tid:%d in TidRefCountMap", t); - continue; - } - mTidSessionListMap[t].erase(session); - mTidRefCountMap[t]--; - if (mTidRefCountMap[t] <= 0) { + size_t cnt = mTidSessionListMap[t].erase(session); + if (cnt != 0 && mTidSessionListMap[t].empty()) { if (!SetTaskProfiles(t, {"NoResetUclampGrp"})) { ALOGW("Failed to set NoResetUclampGrp task profile for tid:%d", t); } - mTidRefCountMap.erase(t); } } - mSessions.erase(session); } void PowerSessionManager::setUclampMin(PowerHintSession *session, int val) { @@ -201,10 +196,6 @@ void PowerSessionManager::handleMessage(const Message &) { } } -void PowerSessionManager::WakeupHandler::handleMessage(const Message &) { - PowerSessionManager::getInstance()->wakeSessions(); -} - void PowerSessionManager::dumpToFd(int fd) { std::ostringstream dump_buf; std::lock_guard<std::mutex> guard(mLock); diff --git a/power-libperfmgr/aidl/PowerSessionManager.h b/power-libperfmgr/aidl/PowerSessionManager.h index 6cd0886c..7c74039a 100644 --- a/power-libperfmgr/aidl/PowerSessionManager.h +++ b/power-libperfmgr/aidl/PowerSessionManager.h @@ -50,6 +50,10 @@ class PowerSessionManager : public MessageHandler { // monitoring session status void addPowerSession(PowerHintSession *session); void removePowerSession(PowerHintSession *session); + void addThreadsFromPowerSession(PowerHintSession *session); + void addThreadsFromPowerSessionLocked(PowerHintSession *session); + void removeThreadsFromPowerSession(PowerHintSession *session); + void removeThreadsFromPowerSessionLocked(PowerHintSession *session); void setUclampMin(PowerHintSession *session, int min); void setUclampMinLocked(PowerHintSession *session, int min); void handleMessage(const Message &message) override; @@ -62,23 +66,13 @@ class PowerSessionManager : public MessageHandler { } private: - class WakeupHandler : public MessageHandler { - public: - WakeupHandler() {} - void handleMessage(const Message &message) override; - }; - - private: - void wakeSessions(); std::optional<bool> isAnyAppSessionActive(); void disableSystemTopAppBoost(); void enableSystemTopAppBoost(); const std::string kDisableBoostHintName; std::unordered_set<PowerHintSession *> mSessions; // protected by mLock - std::unordered_map<int, int> mTidRefCountMap; // protected by mLock std::unordered_map<int, std::unordered_set<PowerHintSession *>> mTidSessionListMap; - sp<WakeupHandler> mWakeupHandler; bool mActive; // protected by mLock /** * mLock to pretect the above data objects opertions. @@ -90,9 +84,7 @@ class PowerSessionManager : public MessageHandler { : kDisableBoostHintName(::android::base::GetProperty(kPowerHalAdpfDisableTopAppBoost, "ADPF_DISABLE_TA_BOOST")), mActive(false), - mDisplayRefreshRate(60) { - mWakeupHandler = sp<WakeupHandler>(new WakeupHandler()); - } + mDisplayRefreshRate(60) {} PowerSessionManager(PowerSessionManager const &) = delete; void operator=(PowerSessionManager const &) = delete; }; diff --git a/power-libperfmgr/aidl/android.hardware.power-service.pixel.xml b/power-libperfmgr/aidl/android.hardware.power-service.pixel.xml index 927ba22d..f5dd6b95 100644 --- a/power-libperfmgr/aidl/android.hardware.power-service.pixel.xml +++ b/power-libperfmgr/aidl/android.hardware.power-service.pixel.xml @@ -1,7 +1,7 @@ <manifest version="1.0" type="device"> <hal format="aidl"> <name>android.hardware.power</name> - <version>3</version> + <version>4</version> <fqname>IPower/default</fqname> </hal> </manifest> diff --git a/power-libperfmgr/aidl/device.mk b/power-libperfmgr/aidl/device.mk index c8485975..300f9f1c 100644 --- a/power-libperfmgr/aidl/device.mk +++ b/power-libperfmgr/aidl/device.mk @@ -1,5 +1,14 @@ BOARD_SEPOLICY_DIRS += hardware/google/pixel-sepolicy/power-libperfmgr +# sendhint utility +PRODUCT_PACKAGES += \ + sendhint + # power HAL PRODUCT_PACKAGES += \ android.hardware.power-service.pixel-libperfmgr + +# Enable adpf cpu hint session for SurfaceFlinger and HWUI +PRODUCT_DEFAULT_PROPERTY_OVERRIDES += \ + debug.sf.enable_adpf_cpu_hint=true \ + debug.hwui.use_hint_manager=true diff --git a/power-libperfmgr/aidl/service.cpp b/power-libperfmgr/aidl/service.cpp index 9b606184..c3e2dd1d 100644 --- a/power-libperfmgr/aidl/service.cpp +++ b/power-libperfmgr/aidl/service.cpp @@ -28,10 +28,8 @@ #include "Power.h" #include "PowerExt.h" #include "PowerSessionManager.h" -#include "adaptivecpu/AdaptiveCpu.h" #include "disp-power/DisplayLowPower.h" -using aidl::google::hardware::power::impl::pixel::AdaptiveCpu; using aidl::google::hardware::power::impl::pixel::DisplayLowPower; using aidl::google::hardware::power::impl::pixel::Power; using aidl::google::hardware::power::impl::pixel::PowerExt; @@ -53,15 +51,13 @@ int main() { // single thread ABinderProcess_setThreadPoolMaxThreadCount(0); - std::shared_ptr<AdaptiveCpu> adaptiveCpu = std::make_shared<AdaptiveCpu>(); - // core service - std::shared_ptr<Power> pw = ndk::SharedRefBase::make<Power>(dlpw, adaptiveCpu); + std::shared_ptr<Power> pw = ndk::SharedRefBase::make<Power>(dlpw); ndk::SpAIBinder pwBinder = pw->asBinder(); AIBinder_setMinSchedulerPolicy(pwBinder.get(), SCHED_NORMAL, -20); // extension service - std::shared_ptr<PowerExt> pwExt = ndk::SharedRefBase::make<PowerExt>(dlpw, adaptiveCpu); + std::shared_ptr<PowerExt> pwExt = ndk::SharedRefBase::make<PowerExt>(dlpw); auto pwExtBinder = pwExt->asBinder(); AIBinder_setMinSchedulerPolicy(pwExtBinder.get(), SCHED_NORMAL, -20); diff --git a/power-libperfmgr/libperfmgr/Android.bp b/power-libperfmgr/libperfmgr/Android.bp index 9527cb7a..9964c51a 100644 --- a/power-libperfmgr/libperfmgr/Android.bp +++ b/power-libperfmgr/libperfmgr/Android.bp @@ -39,8 +39,10 @@ cc_defaults { "cert-*", "clang-analyzer-security*", ], - tidy_flags: [ - "-warnings-as-errors=android-*,clang-analyzer-security*,cert-*" + tidy_checks_as_errors: [ + "android-*", + "clang-analyzer-security*", + "cert-*", ], } diff --git a/power-libperfmgr/libperfmgr/HintManager.cc b/power-libperfmgr/libperfmgr/HintManager.cc index 73ebc438..8c84c685 100644 --- a/power-libperfmgr/libperfmgr/HintManager.cc +++ b/power-libperfmgr/libperfmgr/HintManager.cc @@ -125,6 +125,11 @@ void HintManager::EndHintStatus(const std::string &hint_type) { void HintManager::DoHintAction(const std::string &hint_type) { for (auto &action : actions_.at(hint_type).hint_actions) { + if (!action.enable_property.empty() && + !android::base::GetBoolProperty(action.enable_property, true)) { + // Disabled action based on its control property + continue; + } switch (action.type) { case HintActionType::DoHint: DoHint(action.value); @@ -537,6 +542,7 @@ std::unordered_map<std::string, Hint> HintManager::ParseActions( HintActionType action_type = HintActionType::Node; std::string type_string = actions[i]["Type"].asString(); + std::string enable_property = actions[i]["EnableProperty"].asString(); LOG(VERBOSE) << "Action[" << i << "]'s Type: " << type_string; if (type_string.empty()) { LOG(VERBOSE) << "Failed to read " @@ -599,7 +605,7 @@ std::unordered_map<std::string, Hint> HintManager::ParseActions( } } actions_parsed[hint_type].node_actions.emplace_back( - node_index, value_index, std::chrono::milliseconds(duration)); + node_index, value_index, std::chrono::milliseconds(duration), enable_property); } else { const std::string &hint_value = actions[i]["Value"].asString(); @@ -610,7 +616,8 @@ std::unordered_map<std::string, Hint> HintManager::ParseActions( actions_parsed.clear(); return actions_parsed; } - actions_parsed[hint_type].hint_actions.emplace_back(action_type, hint_value); + actions_parsed[hint_type].hint_actions.emplace_back(action_type, hint_value, + enable_property); } ++total_parsed; diff --git a/power-libperfmgr/libperfmgr/NodeLooperThread.cc b/power-libperfmgr/libperfmgr/NodeLooperThread.cc index 39ffc2e2..d38501d5 100644 --- a/power-libperfmgr/libperfmgr/NodeLooperThread.cc +++ b/power-libperfmgr/libperfmgr/NodeLooperThread.cc @@ -21,6 +21,7 @@ #include <android-base/file.h> #include <android-base/logging.h> +#include <android-base/properties.h> #include <utils/Trace.h> namespace android { @@ -39,6 +40,11 @@ bool NodeLooperThread::Request(const std::vector<NodeAction>& actions, bool ret = true; ::android::AutoMutex _l(lock_); for (const auto& a : actions) { + if (!a.enable_property.empty() && + !android::base::GetBoolProperty(a.enable_property, true)) { + // Disabled action based on its control property + continue; + } if (a.node_index >= nodes_.size()) { LOG(ERROR) << "Node index out of bound: " << a.node_index << " ,size: " << nodes_.size(); diff --git a/power-libperfmgr/libperfmgr/config_schema.json b/power-libperfmgr/libperfmgr/config_schema.json deleted file mode 100644 index 712af500..00000000 --- a/power-libperfmgr/libperfmgr/config_schema.json +++ /dev/null @@ -1,126 +0,0 @@ -{ - "definitions": {}, - "$schema": "http://json-schema.org/draft-06/schema#", - "type": "object", - "id": "config_schema.json", - "required": [ - "Nodes", - "Actions" - ], - "properties": { - "Nodes": { - "type": "array", - "id": "/properties/Nodes", - "minItems": 1, - "uniqueItems": true, - "items": { - "type": "object", - "id": "/properties/Nodes/items", - "required": [ - "Name", - "Path", - "Values" - ], - "properties": { - "Name": { - "type": "string", - "id": "/properties/Nodes/items/properties/Name", - "title": "The Name Schema.", - "description": "The name of the node.", - "minLength": 1 - }, - "Path": { - "type": "string", - "id": "/properties/Nodes/items/properties/Path", - "title": "The Path Schema.", - "description": "For File type node, it is filesystem path of the file; for Property type node, it is the key of the property.", - "minLength": 1 - }, - "Values": { - "type": "array", - "id": "/properties/Nodes/items/properties/Values", - "minItems": 1, - "uniqueItems": true, - "items": { - "type": "string", - "id": "/properties/Nodes/items/properties/Values/items", - "title": "The Values Schema.", - "description": "The Values array lists all possible values that can be set in the Actions section, and the list of values is sorted based on their priority, with the highest priority first." - } - }, - "DefaultIndex": { - "type": "integer", - "id": "/properties/Nodes/items/properties/DefaultIndex", - "title": "The Default Index Schema.", - "description": "The default index of the node, if not present, it will be set to max index of Values.", - "minimum": 0 - }, - "ResetOnInit": { - "type": "boolean", - "id": "/properties/Nodes/items/properties/ResetOnInit", - "title": "The Reset On Init Schema.", - "description": "Flag if node will be set to default value on initialization; if not present, it will be set to false." - }, - "Type": { - "type": "string", - "id": "/properties/Nodes/items/properties/Type", - "title": "The type Schema.", - "description": "Type of Node (File or Property), if not present, it will be set to File." - }, - "HoldFd": { - "type": "boolean", - "id": "/properties/Nodes/items/properties/HoldFd", - "title": "The Hold Fd Schema.", - "description": "Flag if node will hold the file descriptor on non-default values; if not present, it will be set to false. This is only honoured for File type node." - } - } - } - }, - "Actions": { - "type": "array", - "id": "/properties/Actions", - "minItems": 1, - "uniqueItems": true, - "items": { - "type": "object", - "id": "/properties/Actions/items", - "required": [ - "PowerHint", - "Node", - "ValueIndex", - "Duration" - ], - "properties": { - "PowerHint": { - "type": "string", - "id": "/properties/Actions/items/properties/PowerHint", - "title": "The PowerHint Schema.", - "description": "The PowerHint name of the action.", - "minLength": 1 - }, - "Node": { - "type": "string", - "id": "/properties/Actions/items/properties/Node", - "title": "The Node Schema.", - "description": "The Node name of the action, which is defined in Nodes.", - "minLength": 1 - }, - "Value": { - "type": "string", - "id": "/properties/Actions/items/properties/Value", - "title": "The Value Index Schema.", - "description": "The value of action, which is defined in Nodes.", - "minLength": 1 - }, - "Duration": { - "type": "integer", - "id": "/properties/Actions/items/properties/Duration", - "title": "The Duration Schema.", - "description": "The number of milliseconds that this action will be active (zero means forever).", - "minimum": 0 - } - } - } - } - } -} diff --git a/power-libperfmgr/libperfmgr/include/perfmgr/HintManager.h b/power-libperfmgr/libperfmgr/include/perfmgr/HintManager.h index d360fea0..13211a18 100644 --- a/power-libperfmgr/libperfmgr/include/perfmgr/HintManager.h +++ b/power-libperfmgr/libperfmgr/include/perfmgr/HintManager.h @@ -61,9 +61,11 @@ struct HintStatus { enum class HintActionType { Node, DoHint, EndHint, MaskHint }; struct HintAction { - HintAction(HintActionType t, const std::string &v) : type(t), value(v) {} + HintAction(HintActionType t, const std::string &v, const std::string &p) + : type(t), value(v), enable_property(p) {} HintActionType type; std::string value; + std::string enable_property; }; struct Hint { diff --git a/power-libperfmgr/libperfmgr/include/perfmgr/NodeLooperThread.h b/power-libperfmgr/libperfmgr/include/perfmgr/NodeLooperThread.h index eba0fc7f..bad233c7 100644 --- a/power-libperfmgr/libperfmgr/include/perfmgr/NodeLooperThread.h +++ b/power-libperfmgr/libperfmgr/include/perfmgr/NodeLooperThread.h @@ -34,13 +34,15 @@ namespace perfmgr { // timeout for this action: struct NodeAction { NodeAction(std::size_t node_index, std::size_t value_index, - std::chrono::milliseconds timeout_ms) + std::chrono::milliseconds timeout_ms, const std::string &enable_property = "") : node_index(node_index), value_index(value_index), - timeout_ms(timeout_ms) {} + timeout_ms(timeout_ms), + enable_property(enable_property) {} std::size_t node_index; std::size_t value_index; std::chrono::milliseconds timeout_ms; // 0ms for forever + std::string enable_property; // boolean property to control action on/off. }; // The NodeLooperThread is responsible for managing each of the sysfs nodes diff --git a/power-libperfmgr/libperfmgr/tests/HintManagerTest.cc b/power-libperfmgr/libperfmgr/tests/HintManagerTest.cc index 48a84947..979e7dc0 100644 --- a/power-libperfmgr/libperfmgr/tests/HintManagerTest.cc +++ b/power-libperfmgr/libperfmgr/tests/HintManagerTest.cc @@ -68,6 +68,16 @@ constexpr char kJSON_RAW[] = R"( "NONE" ], "Type": "Property" + }, + { + "Name": "TestEnableProperty", + "Path": "vendor.pwhal.enable.test", + "Values": [ + "0", + "1" + ], + "Type": "Property", + "ResetOnInit": true } ], "Actions": [ @@ -87,6 +97,7 @@ constexpr char kJSON_RAW[] = R"( "PowerHint": "LAUNCH", "Node": "CPUCluster0MinFreq", "Value": "1134000", + "EnableProperty": "vendor.pwhal.enable.no_exist", "Duration": 500 }, { @@ -99,9 +110,16 @@ constexpr char kJSON_RAW[] = R"( "PowerHint": "LAUNCH", "Node": "CPUCluster1MinFreq", "Value": "1512000", + "EnableProperty": "vendor.pwhal.enable.test", "Duration": 2000 }, { + "PowerHint": "DISABLE_LAUNCH_ACT2", + "Node": "TestEnableProperty", + "Value": "0", + "Duration": 0 + }, + { "PowerHint": "MASK_LAUNCH_MODE", "Type": "MaskHint", "Value": "LAUNCH" @@ -410,7 +428,7 @@ TEST_F(HintManagerTest, HintStatsTest) { TEST_F(HintManagerTest, ParseNodesTest) { std::vector<std::unique_ptr<Node>> nodes = HintManager::ParseNodes(json_doc_); - EXPECT_EQ(3u, nodes.size()); + EXPECT_EQ(4u, nodes.size()); EXPECT_EQ("CPUCluster0MinFreq", nodes[0]->GetName()); EXPECT_EQ("CPUCluster1MinFreq", nodes[1]->GetName()); EXPECT_EQ(files_[0 + 2]->path, nodes[0]->GetPath()); @@ -503,7 +521,7 @@ TEST_F(HintManagerTest, ParsePropertyNodesEmptyValueTest) { json_doc_.replace(start_pos, from.length(), ""); std::vector<std::unique_ptr<Node>> nodes = HintManager::ParseNodes(json_doc_); - EXPECT_EQ(3u, nodes.size()); + EXPECT_EQ(4u, nodes.size()); EXPECT_EQ("CPUCluster0MinFreq", nodes[0]->GetName()); EXPECT_EQ("CPUCluster1MinFreq", nodes[1]->GetName()); EXPECT_EQ(files_[0 + 2]->path, nodes[0]->GetPath()); @@ -546,7 +564,7 @@ TEST_F(HintManagerTest, ParseActionsTest) { std::vector<std::unique_ptr<Node>> nodes = HintManager::ParseNodes(json_doc_); std::unordered_map<std::string, Hint> actions = HintManager::ParseActions(json_doc_, nodes); - EXPECT_EQ(6u, actions.size()); + EXPECT_EQ(7u, actions.size()); EXPECT_EQ(2u, actions["INTERACTION"].node_actions.size()); EXPECT_EQ(1u, actions["INTERACTION"].node_actions[0].node_index); @@ -575,6 +593,7 @@ TEST_F(HintManagerTest, ParseActionsTest) { EXPECT_EQ(0u, actions["LAUNCH"].node_actions[2].value_index); EXPECT_EQ(std::chrono::milliseconds(2000).count(), actions["LAUNCH"].node_actions[2].timeout_ms.count()); + EXPECT_EQ("vendor.pwhal.enable.test", actions["LAUNCH"].node_actions[2].enable_property); EXPECT_EQ(1u, actions["MASK_LAUNCH_MODE"].hint_actions.size()); EXPECT_EQ(HintActionType::MaskHint, actions["MASK_LAUNCH_MODE"].hint_actions[0].type); @@ -604,7 +623,7 @@ TEST_F(HintManagerTest, ParseActionDuplicateFileNodeTest) { json_doc_.replace(start_pos, from.length(), R"("Node": "CPUCluster1MinFreq")"); std::vector<std::unique_ptr<Node>> nodes = HintManager::ParseNodes(json_doc_); - EXPECT_EQ(3u, nodes.size()); + EXPECT_EQ(4u, nodes.size()); auto actions = HintManager::ParseActions(json_doc_, nodes); EXPECT_EQ(0u, actions.size()); } @@ -615,7 +634,7 @@ TEST_F(HintManagerTest, ParseActionDuplicatePropertyNodeTest) { size_t start_pos = json_doc_.find(from); json_doc_.replace(start_pos, from.length(), R"("Node": "ModeProperty")"); auto nodes = HintManager::ParseNodes(json_doc_); - EXPECT_EQ(3u, nodes.size()); + EXPECT_EQ(4u, nodes.size()); auto actions = HintManager::ParseActions(json_doc_, nodes); EXPECT_EQ(0u, actions.size()); } @@ -660,6 +679,7 @@ TEST_F(HintManagerTest, GetFromJSONTest) { _VerifyPathValue(files_[1 + 2]->path, "1134000"); _VerifyPropertyValue(prop_, "LOW"); // Do LAUNCH + _VerifyPropertyValue("vendor.pwhal.enable.test", "1"); EXPECT_TRUE(hm->DoHint("LAUNCH")); std::this_thread::sleep_for(kSLEEP_TOLERANCE_MS); _VerifyPathValue(files_[0 + 2]->path, "1134000"); @@ -682,6 +702,21 @@ TEST_F(HintManagerTest, GetFromJSONTest) { _VerifyPathValue(files_[1 + 2]->path, "384000"); _VerifyPropertyValue(prop_, "NONE"); + // Disable action[2] of LAUNCH + EXPECT_TRUE(hm->EndHint("LAUNCH")); + _VerifyPropertyValue("vendor.pwhal.enable.test", "1"); + EXPECT_TRUE(hm->DoHint("DISABLE_LAUNCH_ACT2")); + std::this_thread::sleep_for(kSLEEP_TOLERANCE_MS); + _VerifyPropertyValue("vendor.pwhal.enable.test", "0"); + EXPECT_TRUE(hm->DoHint("LAUNCH")); + std::this_thread::sleep_for(kSLEEP_TOLERANCE_MS); + _VerifyPathValue(files_[0 + 2]->path, "1134000"); + // action[2] have no effect. + _VerifyPathValue(files_[1 + 2]->path, "384000"); + _VerifyPropertyValue(prop_, "HIGH"); + EXPECT_TRUE(hm->EndHint("LAUNCH")); + EXPECT_TRUE(hm->EndHint("DISABLE_LAUNCH_ACT2")); + // Mask LAUNCH and do LAUNCH EXPECT_TRUE(hm->DoHint("MASK_LAUNCH_MODE")); EXPECT_FALSE(hm->DoHint("LAUNCH")); // should fail diff --git a/power-libperfmgr/utilities/sendhint.cc b/power-libperfmgr/utilities/sendhint.cc new file mode 100644 index 00000000..c6b90d0b --- /dev/null +++ b/power-libperfmgr/utilities/sendhint.cc @@ -0,0 +1,160 @@ +/* + * Copyright (C) 2023 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. + */ + +#include <aidl/android/hardware/power/IPower.h> +#include <aidl/google/hardware/power/extension/pixel/IPowerExt.h> +#include <android-base/logging.h> +#include <android/binder_manager.h> + +#include <getopt.h> + +using ::aidl::android::hardware::power::IPower; +using ::aidl::google::hardware::power::extension::pixel::IPowerExt; + +static void DualLogger(android::base::LogId id, android::base::LogSeverity severity, + const char *tag, const char *file, unsigned int line, const char *message) { + android::base::KernelLogger(id, severity, tag, file, line, message); + android::base::StderrLogger(id, severity, tag, file, line, message); +} + +static void printUsage(const char *exec_name) { + android::base::SetLogger(android::base::StderrLogger); + std::string usage = exec_name; + usage = usage + + " is a command-line tool to send hint to Pixel Power HAL.\n" + "Usages:\n" + + exec_name + + " [options]\n" + "\n" + "Options:\n" + " --mode, -m\n" + " Mode for hint\n\n" + " --enable, -e\n" + " 1 for enable mode, 0 for disable\n\n" + " --boost, -b\n" + " Boost for hint\n\n" + " --duration, -d\n" + " Boost duration\n\n" + " --help, -h\n" + " print this message\n\n"; + + LOG(INFO) << usage; +} + +static std::shared_ptr<IPowerExt> connect() { + const std::string kInstance = std::string(IPower::descriptor) + "/default"; + ndk::SpAIBinder power_binder = ndk::SpAIBinder(AServiceManager_getService(kInstance.c_str())); + ndk::SpAIBinder ext_power_binder; + std::shared_ptr<IPowerExt> powerext = nullptr; + + if (power_binder.get() == nullptr) { + LOG(ERROR) << "Cannot get Power Hal Binder"; + return powerext; + } + + if (STATUS_OK != AIBinder_getExtension(power_binder.get(), ext_power_binder.getR()) || + ext_power_binder.get() == nullptr) { + LOG(ERROR) << "Cannot get Power Hal Extension Binder"; + return powerext; + } + + powerext = IPowerExt::fromBinder(ext_power_binder); + if (powerext == nullptr) { + LOG(ERROR) << "Cannot get Power Hal Extension AIDL"; + } + + return powerext; +} + +static bool setMode(std::shared_ptr<IPowerExt> hal, const std::string &type, const bool &enable) { + if (!hal->setMode(type, enable).isOk()) { + LOG(ERROR) << "Fail to set mode: " << type << " enabled: " << enable; + return false; + } else { + LOG(INFO) << "Set mode: " << type << " enabled: " << enable; + return true; + } +} + +static bool setBoost(std::shared_ptr<IPowerExt> hal, const std::string &type, + const int32_t duration_ms) { + if (!hal->setBoost(type, duration_ms).isOk()) { + LOG(ERROR) << "Fail to set boost: " << type << " duration: " << duration_ms; + return false; + } else { + LOG(INFO) << "Set boost: " << type << " duration: " << duration_ms; + return true; + } +} + +int main(int argc, char *argv[]) { + android::base::SetLogger(DualLogger); + std::string boost; + unsigned int duration_ms = 0; + std::string mode; + bool enabled = true; + + static struct option opts[] = { + {"boost", optional_argument, nullptr, 'b'}, + {"duration", optional_argument, nullptr, 'd'}, + {"mode", optional_argument, nullptr, 'm'}, + {"enable", optional_argument, nullptr, 'e'}, + {0, 0, 0, 0} // termination of the option list + }; + + int c = -1; + while ((c = getopt_long(argc, argv, "b:d:m:e:h", opts, nullptr)) != -1) { + switch (c) { + case 'b': + boost = optarg; + break; + case 'd': + duration_ms = std::stoi(optarg); + break; + case 'm': + mode = optarg; + break; + case 'e': + enabled = std::stoi(optarg); + break; + case 'h': + printUsage(argv[0]); + return 0; + default: + printUsage(argv[0]); + return 1; + } + } + if (boost.empty() && mode.empty()) { + LOG(ERROR) << "Need specify a boost or mode to send hint"; + printUsage(argv[0]); + return 1; + } + + std::shared_ptr<IPowerExt> powerext = connect(); + if (!powerext) { + return 1; + } + + if (!boost.empty() && !setBoost(powerext, boost, duration_ms)) { + return 1; + } + + if (!mode.empty() && !setMode(powerext, mode, enabled)) { + return 1; + } + return 0; +} diff --git a/powerstats/Android.bp b/powerstats/Android.bp index 394c07b2..2b0ffa1f 100644 --- a/powerstats/Android.bp +++ b/powerstats/Android.bp @@ -57,7 +57,7 @@ cc_defaults { "liblog", "libutils", "pixel_stateresidency_provider_aidl_interface-ndk", - "android.hardware.power.stats-V1-ndk", + "android.hardware.power.stats-V2-ndk", ], } diff --git a/powerstats/GenericStateResidencyDataProvider.cpp b/powerstats/GenericStateResidencyDataProvider.cpp index 5723904b..3bdd9ba1 100644 --- a/powerstats/GenericStateResidencyDataProvider.cpp +++ b/powerstats/GenericStateResidencyDataProvider.cpp @@ -131,7 +131,7 @@ static bool getStateData( auto endState = stateResidencyConfigs.cend(); auto pred = [](auto a, char const *b) { // return true if b matches the header contained in a, ignoring whitespace - return (a.second.header == android::base::Trim(std::string(b))); + return (a.second.header == android::base::Trim(b)); }; result->stateResidencyData.resize(numStates); @@ -176,7 +176,7 @@ bool GenericStateResidencyDataProvider::getResults( auto endConfig = mPowerEntityConfigs.cend(); auto pred = [](auto a, char const *b) { // return true if b matches the header contained in a, ignoring whitespace - return (a.second.mHeader == android::base::Trim(std::string(b))); + return (a.second.mHeader == android::base::Trim(b)); }; bool skipFindNext = false; diff --git a/powerstats/OWNERS b/powerstats/OWNERS index 47edc196..e0d66d72 100644 --- a/powerstats/OWNERS +++ b/powerstats/OWNERS @@ -1,4 +1,4 @@ -bsschwar@google.com +darrenhsu@google.com +joaodias@google.com krossmo@google.com -tstrudel@google.com - +vincentwang@google.com diff --git a/powerstats/aidl/Android.bp b/powerstats/aidl/Android.bp index 8dc02aac..2f03c1ba 100644 --- a/powerstats/aidl/Android.bp +++ b/powerstats/aidl/Android.bp @@ -33,7 +33,7 @@ aidl_interface { aidl_interface { name: "pixel_stateresidency_provider_aidl_interface", unstable: true, - imports: ["android.hardware.power.stats-V1"], + imports: ["android.hardware.power.stats-V2"], srcs: [ "android/vendor/powerstats/IPixelStateResidencyProvider.aidl", "android/vendor/powerstats/IPixelStateResidencyCallback.aidl", diff --git a/powerstats/android.hardware.power.stats-service.pixel.rc b/powerstats/android.hardware.power.stats-service.pixel.rc index f5e49f23..01ec05ca 100644 --- a/powerstats/android.hardware.power.stats-service.pixel.rc +++ b/powerstats/android.hardware.power.stats-service.pixel.rc @@ -1,3 +1,17 @@ +# ODPM: change VSYS_PWR_MMWAVE to S9M_LLDO3 on sub6 device +# detail: b/231463665#10 +on early-boot && property:ro.boot.hardware.sku=GP4BC + write /sys/bus/iio/devices/iio:device0/enabled_rails "CH0=BUCK9M" + +on early-boot && property:ro.boot.hardware.sku=GFE4J + write /sys/bus/iio/devices/iio:device0/enabled_rails "CH0=BUCK9M" + +on early-boot && property:ro.boot.hardware.sku=GVU6C + write /sys/bus/iio/devices/iio:device0/enabled_rails "CH0=BUCK9M" + +on early-boot && property:ro.boot.hardware.sku=G03Z5 + write /sys/bus/iio/devices/iio:device0/enabled_rails "CH0=BUCK9M" + service vendor.power.stats /vendor/bin/hw/android.hardware.power.stats-service.pixel class hal user system diff --git a/powerstats/android.hardware.power.stats-service.pixel.xml b/powerstats/android.hardware.power.stats-service.pixel.xml index 3b1a2161..b64ea7e2 100644 --- a/powerstats/android.hardware.power.stats-service.pixel.xml +++ b/powerstats/android.hardware.power.stats-service.pixel.xml @@ -1,6 +1,7 @@ <manifest version="1.0" type="device"> <hal format="aidl"> <name>android.hardware.power.stats</name> + <version>2</version> <fqname>IPowerStats/default</fqname> </hal> </manifest> diff --git a/powerstats/dataproviders/DisplayStateResidencyDataProvider.cpp b/powerstats/dataproviders/DisplayStateResidencyDataProvider.cpp index c074bf69..fa53d825 100644 --- a/powerstats/dataproviders/DisplayStateResidencyDataProvider.cpp +++ b/powerstats/dataproviders/DisplayStateResidencyDataProvider.cpp @@ -30,6 +30,8 @@ namespace hardware { namespace power { namespace stats { +static const int32_t POLL_TIMEOUT_MILLIS = 300; + DisplayStateResidencyDataProvider::DisplayStateResidencyDataProvider( std::string name, std::string path, std::vector<std::string> states) : mPath(std::move(path)), @@ -100,6 +102,7 @@ std::unordered_map<std::string, std::vector<State>> DisplayStateResidencyDataPro // display state file descriptor indicating a state change void DisplayStateResidencyDataProvider::updateStats() { char data[32]; + char *trim; // Get current time since boot in milliseconds uint64_t now = std::chrono::duration_cast<std::chrono::milliseconds>( @@ -111,15 +114,23 @@ void DisplayStateResidencyDataProvider::updateStats() { PLOG(ERROR) << "Failed to read display state"; return; } - data[ret] = '\0'; - LOG(VERBOSE) << "display state: " << data; + trim = strchr(data, '\n'); + if (trim) { + data[trim - data] = '\0'; + } // Update residency stats based on state read { // acquire lock std::scoped_lock lk(mLock); for (uint32_t i = 0; i < mStates.size(); ++i) { - if (strstr(data, mStates[i].c_str())) { + if (strcmp(data, mStates[i].c_str()) == 0) { + if (i == mCurState) { + break; + } + + LOG(VERBOSE) << "display state: " << data; + // Update total time of the previous state if (mCurState > -1) { mResidencies[mCurState].totalTimeInStateMs += @@ -137,10 +148,12 @@ void DisplayStateResidencyDataProvider::updateStats() { } void DisplayStateResidencyDataProvider::pollLoop() { + int32_t res; LOG(VERBOSE) << "DisplayStateResidencyDataProvider polling..."; while (true) { - // Poll for display state changes. Timeout set to poll indefinitely - if (mLooper->pollOnce(-1) >= 0) { + // Poll for display state changes. + res = mLooper->pollOnce(POLL_TIMEOUT_MILLIS); + if (res >= 0 || res == ::android::Looper::POLL_TIMEOUT) { updateStats(); } } diff --git a/powerstats/dataproviders/GenericStateResidencyDataProvider.cpp b/powerstats/dataproviders/GenericStateResidencyDataProvider.cpp index dae52ccb..627e0297 100644 --- a/powerstats/dataproviders/GenericStateResidencyDataProvider.cpp +++ b/powerstats/dataproviders/GenericStateResidencyDataProvider.cpp @@ -114,7 +114,7 @@ static bool getStateData(std::vector<StateResidency> *result, int32_t nextState = -1; auto pred = [](auto a, char const *b) { // return true if b matches the header contained in a, ignoring whitespace - return (a.header == ::android::base::Trim(std::string(b))); + return (a.header == ::android::base::Trim(b)); }; result->reserve(numStates); @@ -157,7 +157,7 @@ bool GenericStateResidencyDataProvider::getStateResidencies( int32_t nextConfig = -1; auto pred = [](auto a, char const *b) { // return true if b matches the header contained in a, ignoring whitespace - return (a.mHeader == ::android::base::Trim(std::string(b))); + return (a.mHeader == ::android::base::Trim(b)); }; // Search for entity headers until we have found them all or can't find anymore diff --git a/pwrstats_util/Android.bp b/pwrstats_util/Android.bp index 6c249a0f..c3efaa9d 100644 --- a/pwrstats_util/Android.bp +++ b/pwrstats_util/Android.bp @@ -61,18 +61,17 @@ cc_defaults { "misc-*", "performance-*", ], - tidy_flags: [ - "-warnings-as-errors=" - + "android-*" - + ",clang-analyzer-security*" - + ",cert-*" - + ",google-*" - + ",performance-*" - + ",misc-*" - + ",-cert-oop54-cpp" // in powerstats_util.pb.h - + ",-bugprone-unhandled-self-assignment" // in powerstats_util.pb.h - + ",-google-global-names-in-headers" // in PowerStatsCollector.h - + ",-google-readability-casting" // in pwrstatsutil.pb.h + tidy_checks_as_errors: [ + "android-*", + "clang-analyzer-security*", + "cert-*", + "google-*", + "performance-*", + "misc-*", + "-cert-oop54-cpp", // in powerstats_util.pb.h + "-bugprone-unhandled-self-assignment", // in powerstats_util.pb.h + "-google-global-names-in-headers", // in PowerStatsCollector.h + "-google-readability-casting", // in pwrstatsutil.pb.h ], shared_libs: [ "libbase", diff --git a/radio/Android.bp b/radio/Android.bp index b41a09d3..b7f71079 100644 --- a/radio/Android.bp +++ b/radio/Android.bp @@ -1,13 +1,13 @@ // Define the soong config module for Pixel in this Android.bp
-package { - default_applicable_licenses: ["Android-Apache-2.0"], -} - +package {
+ default_applicable_licenses: ["Android-Apache-2.0"],
+}
+
soong_config_module_type {
name: "pixel_glog_cc_defaults",
module_type: "cc_defaults",
config_namespace: "glog",
bool_variables: ["enable_glog"],
- properties: ["cflags", "shared_libs", "header_libs"],
+ properties: ["cflags", "shared_libs", "header_libs","export_header_lib_headers"],
}
diff --git a/radio/gril_carrier_nv_headers/Android.bp b/radio/gril_carrier_nv_headers/Android.bp index 845945ab..0b4765fb 100644 --- a/radio/gril_carrier_nv_headers/Android.bp +++ b/radio/gril_carrier_nv_headers/Android.bp @@ -7,6 +7,7 @@ cc_library_headers { sanitize:{ integer_overflow: true, }, + host_supported: true, vendor: true, export_include_dirs: [ "inc/", diff --git a/thermal/Android.bp b/thermal/Android.bp index 4ad1cabc..86f6cb69 100644 --- a/thermal/Android.bp +++ b/thermal/Android.bp @@ -2,77 +2,47 @@ package { default_applicable_licenses: ["Android-Apache-2.0"], } -soong_config_module_type { - name: "thermal_hal_feature_cc_defaults", - module_type: "cc_defaults", - config_namespace: "thermal_hal_feature", - variables: ["pid"], - properties: ["cflags", "srcs"], -} - -soong_config_string_variable { - name: "pid", - values: ["apply_1_0", "apply_2_0"], -} - -thermal_hal_feature_cc_defaults { - name: "thermal_hal_feature_defaults", - soong_config_variables: { - pid: { - apply_1_0: { - srcs: [ - "pid_1_0/service.cpp", - "pid_1_0/Thermal.cpp", - "pid_1_0/thermal-helper.cpp", - "pid_1_0/utils/thermal_throttling.cpp", - "pid_1_0/utils/thermal_info.cpp", - "pid_1_0/utils/thermal_files.cpp", - "pid_1_0/utils/power_files.cpp", - "pid_1_0/utils/powerhal_helper.cpp", - "pid_1_0/utils/thermal_watcher.cpp", - ], - }, - apply_2_0: { - srcs: [ - "service.cpp", - "Thermal.cpp", - "thermal-helper.cpp", - "utils/thermal_throttling.cpp", - "utils/thermal_info.cpp", - "utils/thermal_files.cpp", - "utils/power_files.cpp", - "utils/powerhal_helper.cpp", - "utils/thermal_watcher.cpp", - ], - }, - }, - }, -} - cc_binary { - name: "android.hardware.thermal@2.0-service.pixel", - defaults: [ - "hidl_defaults", - "thermal_hal_feature_defaults", + name: "android.hardware.thermal-service.pixel", + srcs: [ + "service.cpp", + "Thermal.cpp", + "thermal-helper.cpp", + "utils/thermal_throttling.cpp", + "utils/thermal_info.cpp", + "utils/thermal_files.cpp", + "utils/power_files.cpp", + "utils/powerhal_helper.cpp", + "utils/thermal_stats_helper.cpp", + "utils/thermal_watcher.cpp", ], vendor: true, relative_install_path: "hw", - vintf_fragments: ["android.hardware.thermal@2.0-service.pixel.xml"], + vintf_fragments: [ + "android.hardware.thermal-service.pixel.xml" + ], init_rc: [ - "android.hardware.thermal@2.0-service.pixel.rc", + "android.hardware.thermal-service.pixel.rc", ], shared_libs: [ "libbase", "libcutils", - "libhidlbase", "libjsoncpp", "libutils", "libnl", "libbinder_ndk", - "android.hardware.thermal@1.0", - "android.hardware.thermal@2.0", + "android.frameworks.stats-V1-ndk", "android.hardware.power-V1-ndk", - "pixel-power-ext-V1-ndk" + "android.hardware.thermal-V1-ndk", + "pixel-power-ext-V1-ndk", + "pixelatoms-cpp", + ], + static_libs: [ + "libpixelstats", + ], + export_shared_lib_headers: [ + "android.frameworks.stats-V1-ndk", + "pixelatoms-cpp", ], cflags: [ "-Wall", @@ -86,8 +56,10 @@ cc_binary { "cert-*", "clang-analyzer-security*", ], - tidy_flags: [ - "-warnings-as-errors=android-*,clang-analyzer-security*,cert-*" + tidy_checks_as_errors: [ + "android-*", + "clang-analyzer-security*", + "cert-*", ], } diff --git a/thermal/OWNERS b/thermal/OWNERS index 02055056..ea0b3eda 100644 --- a/thermal/OWNERS +++ b/thermal/OWNERS @@ -1,3 +1,6 @@ wvw@google.com paillon@google.com -jychen@google.com +jenhaochen@google.com +liumartin@google.com +sayanna@google.com +kamewang@google.com diff --git a/thermal/Thermal.cpp b/thermal/Thermal.cpp index 2f41445f..776341dd 100644 --- a/thermal/Thermal.cpp +++ b/thermal/Thermal.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2018 The Android Open Source Project + * Copyright (C) 2022 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. @@ -20,215 +20,122 @@ #include <android-base/file.h> #include <android-base/logging.h> -#include <hidl/HidlTransportSupport.h> #include <utils/Trace.h> -#include <cerrno> -#include <mutex> -#include <string> - -#include "thermal-helper.h" - +namespace aidl { namespace android { namespace hardware { namespace thermal { -namespace V2_0 { namespace implementation { namespace { -using ::android::hardware::interfacesEqual; -using ::android::hardware::thermal::V1_0::ThermalStatus; -using ::android::hardware::thermal::V1_0::ThermalStatusCode; - -template <typename T, typename U> -Return<void> setFailureAndCallback(T _hidl_cb, hidl_vec<U> data, std::string_view debug_msg) { - ThermalStatus status; - status.code = ThermalStatusCode::FAILURE; - status.debugMessage = debug_msg.data(); - _hidl_cb(status, data); - return Void(); +ndk::ScopedAStatus initErrorStatus() { + return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_STATE, + "ThermalHAL not initialized properly."); } -template <typename T, typename U> -Return<void> setInitFailureAndCallback(T _hidl_cb, hidl_vec<U> data) { - return setFailureAndCallback(_hidl_cb, data, "Failure initializing thermal HAL"); +ndk::ScopedAStatus readErrorStatus() { + return ndk::ScopedAStatus::fromExceptionCodeWithMessage( + EX_ILLEGAL_STATE, "ThermalHal cannot read any sensor data"); +} + +bool interfacesEqual(const std::shared_ptr<::ndk::ICInterface> left, + const std::shared_ptr<::ndk::ICInterface> right) { + if (left == nullptr || right == nullptr || !left->isRemote() || !right->isRemote()) { + return left == right; + } + return left->asBinder() == right->asBinder(); } } // namespace -// On init we will spawn a thread which will continually watch for -// throttling. When throttling is seen, if we have a callback registered -// the thread will call notifyThrottling() else it will log the dropped -// throttling event and do nothing. The thread is only killed when -// Thermal() is killed. Thermal::Thermal() : thermal_helper_( std::bind(&Thermal::sendThermalChangedCallback, this, std::placeholders::_1)) {} -// Methods from ::android::hardware::thermal::V1_0::IThermal. -Return<void> Thermal::getTemperatures(getTemperatures_cb _hidl_cb) { - ThermalStatus status; - status.code = ThermalStatusCode::SUCCESS; - hidl_vec<Temperature_1_0> temperatures; - - if (!thermal_helper_.isInitializedOk()) { - LOG(ERROR) << "ThermalHAL not initialized properly."; - return setInitFailureAndCallback(_hidl_cb, temperatures); - } - - if (!thermal_helper_.fillTemperatures(&temperatures)) { - return setFailureAndCallback(_hidl_cb, temperatures, "Failed to read thermal sensors."); - } - - _hidl_cb(status, temperatures); - return Void(); +ndk::ScopedAStatus Thermal::getTemperatures(std::vector<Temperature> *_aidl_return) { + return getFilteredTemperatures(false, TemperatureType::UNKNOWN, _aidl_return); } -Return<void> Thermal::getCpuUsages(getCpuUsages_cb _hidl_cb) { - ThermalStatus status; - status.code = ThermalStatusCode::SUCCESS; - hidl_vec<CpuUsage> cpu_usages; +ndk::ScopedAStatus Thermal::getTemperaturesWithType(TemperatureType type, + std::vector<Temperature> *_aidl_return) { + return getFilteredTemperatures(true, type, _aidl_return); +} +ndk::ScopedAStatus Thermal::getFilteredTemperatures(bool filterType, TemperatureType type, + std::vector<Temperature> *_aidl_return) { + *_aidl_return = {}; if (!thermal_helper_.isInitializedOk()) { - return setInitFailureAndCallback(_hidl_cb, cpu_usages); + return initErrorStatus(); } - - if (!thermal_helper_.fillCpuUsages(&cpu_usages)) { - return setFailureAndCallback(_hidl_cb, cpu_usages, "Failed to get CPU usages."); + if (!thermal_helper_.fillCurrentTemperatures(filterType, false, type, _aidl_return)) { + return readErrorStatus(); } - - _hidl_cb(status, cpu_usages); - return Void(); + return ndk::ScopedAStatus::ok(); } -Return<void> Thermal::getCoolingDevices(getCoolingDevices_cb _hidl_cb) { - ThermalStatus status; - status.code = ThermalStatusCode::SUCCESS; - hidl_vec<CoolingDevice_1_0> cooling_devices; - - if (!thermal_helper_.isInitializedOk()) { - return setInitFailureAndCallback(_hidl_cb, cooling_devices); - } - _hidl_cb(status, cooling_devices); - return Void(); +ndk::ScopedAStatus Thermal::getCoolingDevices(std::vector<CoolingDevice> *_aidl_return) { + return getFilteredCoolingDevices(false, CoolingType::BATTERY, _aidl_return); } -Return<void> Thermal::getCurrentTemperatures(bool filterType, TemperatureType_2_0 type, - getCurrentTemperatures_cb _hidl_cb) { - ThermalStatus status; - status.code = ThermalStatusCode::SUCCESS; - hidl_vec<Temperature_2_0> temperatures; - - if (!thermal_helper_.isInitializedOk()) { - LOG(ERROR) << "ThermalHAL not initialized properly."; - return setInitFailureAndCallback(_hidl_cb, temperatures); - } - - if (!thermal_helper_.fillCurrentTemperatures(filterType, false, type, &temperatures)) { - return setFailureAndCallback(_hidl_cb, temperatures, "Failed to read thermal sensors."); - } - - _hidl_cb(status, temperatures); - return Void(); +ndk::ScopedAStatus Thermal::getCoolingDevicesWithType(CoolingType type, + std::vector<CoolingDevice> *_aidl_return) { + return getFilteredCoolingDevices(true, type, _aidl_return); } -Return<void> Thermal::getTemperatureThresholds(bool filterType, TemperatureType_2_0 type, - getTemperatureThresholds_cb _hidl_cb) { - ThermalStatus status; - status.code = ThermalStatusCode::SUCCESS; - hidl_vec<TemperatureThreshold> temperatures; - +ndk::ScopedAStatus Thermal::getFilteredCoolingDevices(bool filterType, CoolingType type, + std::vector<CoolingDevice> *_aidl_return) { + *_aidl_return = {}; if (!thermal_helper_.isInitializedOk()) { - LOG(ERROR) << "ThermalHAL not initialized properly."; - return setInitFailureAndCallback(_hidl_cb, temperatures); + return initErrorStatus(); } - - if (!thermal_helper_.fillTemperatureThresholds(filterType, type, &temperatures)) { - return setFailureAndCallback(_hidl_cb, temperatures, "Failed to read thermal sensors."); + if (!thermal_helper_.fillCurrentCoolingDevices(filterType, type, _aidl_return)) { + return readErrorStatus(); } + return ndk::ScopedAStatus::ok(); +} - _hidl_cb(status, temperatures); - return Void(); +ndk::ScopedAStatus Thermal::getTemperatureThresholds( + std::vector<TemperatureThreshold> *_aidl_return) { + *_aidl_return = {}; + return getFilteredTemperatureThresholds(false, TemperatureType::UNKNOWN, _aidl_return); } -Return<void> Thermal::getCurrentCoolingDevices(bool filterType, CoolingType type, - getCurrentCoolingDevices_cb _hidl_cb) { - ThermalStatus status; - status.code = ThermalStatusCode::SUCCESS; - hidl_vec<CoolingDevice_2_0> cooling_devices; +ndk::ScopedAStatus Thermal::getTemperatureThresholdsWithType( + TemperatureType type, std::vector<TemperatureThreshold> *_aidl_return) { + return getFilteredTemperatureThresholds(true, type, _aidl_return); +} +ndk::ScopedAStatus Thermal::getFilteredTemperatureThresholds( + bool filterType, TemperatureType type, std::vector<TemperatureThreshold> *_aidl_return) { + *_aidl_return = {}; if (!thermal_helper_.isInitializedOk()) { - LOG(ERROR) << "ThermalHAL not initialized properly."; - return setInitFailureAndCallback(_hidl_cb, cooling_devices); + return initErrorStatus(); } - - if (!thermal_helper_.fillCurrentCoolingDevices(filterType, type, &cooling_devices)) { - return setFailureAndCallback(_hidl_cb, cooling_devices, "Failed to read cooling devices."); + if (!thermal_helper_.fillTemperatureThresholds(filterType, type, _aidl_return)) { + return readErrorStatus(); } - - _hidl_cb(status, cooling_devices); - return Void(); + return ndk::ScopedAStatus::ok(); } -Return<void> Thermal::registerThermalChangedCallback(const sp<IThermalChangedCallback> &callback, - bool filterType, TemperatureType_2_0 type, - registerThermalChangedCallback_cb _hidl_cb) { - ThermalStatus status; - hidl_vec<Temperature_2_0> temperatures; - +ndk::ScopedAStatus Thermal::registerThermalChangedCallback( + const std::shared_ptr<IThermalChangedCallback> &callback) { ATRACE_CALL(); - if (callback == nullptr) { - status.code = ThermalStatusCode::FAILURE; - status.debugMessage = "Invalid nullptr callback"; - LOG(ERROR) << status.debugMessage; - _hidl_cb(status); - return Void(); - } else { - status.code = ThermalStatusCode::SUCCESS; - } - std::lock_guard<std::mutex> _lock(thermal_callback_mutex_); - if (std::any_of(callbacks_.begin(), callbacks_.end(), [&](const CallbackSetting &c) { - return interfacesEqual(c.callback, callback); - })) { - status.code = ThermalStatusCode::FAILURE; - status.debugMessage = "Same callback registered already"; - LOG(ERROR) << status.debugMessage; - } else { - callbacks_.emplace_back(callback, filterType, type); - LOG(INFO) << "a callback has been registered to ThermalHAL, isFilter: " << filterType - << " Type: " << android::hardware::thermal::V2_0::toString(type); - } - _hidl_cb(status); - - // Send notification right away after thermal callback registration - if (thermal_helper_.fillCurrentTemperatures(filterType, true, type, &temperatures)) { - for (const auto &t : temperatures) { - if (!filterType || t.type == type) { - LOG(INFO) << "Sending notification: " - << " Type: " << android::hardware::thermal::V2_0::toString(t.type) - << " Name: " << t.name << " CurrentValue: " << t.value - << " ThrottlingStatus: " - << android::hardware::thermal::V2_0::toString(t.throttlingStatus); - callback->notifyThrottling(t); - } - } - } + return registerThermalChangedCallback(callback, false, TemperatureType::UNKNOWN); +} - return Void(); +ndk::ScopedAStatus Thermal::registerThermalChangedCallbackWithType( + const std::shared_ptr<IThermalChangedCallback> &callback, TemperatureType type) { + ATRACE_CALL(); + return registerThermalChangedCallback(callback, true, type); } -Return<void> Thermal::unregisterThermalChangedCallback( - const sp<IThermalChangedCallback> &callback, unregisterThermalChangedCallback_cb _hidl_cb) { - ThermalStatus status; +ndk::ScopedAStatus Thermal::unregisterThermalChangedCallback( + const std::shared_ptr<IThermalChangedCallback> &callback) { if (callback == nullptr) { - status.code = ThermalStatusCode::FAILURE; - status.debugMessage = "Invalid nullptr callback"; - LOG(ERROR) << status.debugMessage; - _hidl_cb(status); - return Void(); - } else { - status.code = ThermalStatusCode::SUCCESS; + return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT, + "Invalid nullptr callback"); } bool removed = false; std::lock_guard<std::mutex> _lock(thermal_callback_mutex_); @@ -239,8 +146,7 @@ Return<void> Thermal::unregisterThermalChangedCallback( if (interfacesEqual(c.callback, callback)) { LOG(INFO) << "a callback has been unregistered to ThermalHAL, isFilter: " - << c.is_filter_type << " Type: " - << android::hardware::thermal::V2_0::toString(c.type); + << c.is_filter_type << " Type: " << toString(c.type); removed = true; return true; } @@ -248,41 +154,79 @@ Return<void> Thermal::unregisterThermalChangedCallback( }), callbacks_.end()); if (!removed) { - status.code = ThermalStatusCode::FAILURE; - status.debugMessage = "The callback was not registered before"; - LOG(ERROR) << status.debugMessage; + return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT, + "Callback wasn't registered"); } - _hidl_cb(status); - return Void(); + return ndk::ScopedAStatus::ok(); } -void Thermal::sendThermalChangedCallback(const Temperature_2_0 &t) { +ndk::ScopedAStatus Thermal::registerThermalChangedCallback( + const std::shared_ptr<IThermalChangedCallback> &callback, bool filterType, + TemperatureType type) { ATRACE_CALL(); + if (callback == nullptr) { + return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT, + "Invalid nullptr callback"); + } + if (!thermal_helper_.isInitializedOk()) { + return initErrorStatus(); + } std::lock_guard<std::mutex> _lock(thermal_callback_mutex_); - LOG(VERBOSE) << "Sending notification: " - << " Type: " << android::hardware::thermal::V2_0::toString(t.type) - << " Name: " << t.name << " CurrentValue: " << t.value << " ThrottlingStatus: " - << android::hardware::thermal::V2_0::toString(t.throttlingStatus); + if (std::any_of(callbacks_.begin(), callbacks_.end(), [&](const CallbackSetting &c) { + return interfacesEqual(c.callback, callback); + })) { + return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT, + "Callback already registered"); + } + auto c = callbacks_.emplace_back(callback, filterType, type); + LOG(INFO) << "a callback has been registered to ThermalHAL, isFilter: " << c.is_filter_type + << " Type: " << toString(c.type); + // Send notification right away after successful thermal callback registration + std::function<void()> handler = [this, c, filterType, type]() { + std::vector<Temperature> temperatures; + if (thermal_helper_.fillCurrentTemperatures(filterType, true, type, &temperatures)) { + for (const auto &t : temperatures) { + if (!filterType || t.type == type) { + LOG(INFO) << "Sending notification: " + << " Type: " << toString(t.type) << " Name: " << t.name + << " CurrentValue: " << t.value + << " ThrottlingStatus: " << toString(t.throttlingStatus); + c.callback->notifyThrottling(t); + } + } + } + }; + looper_.addEvent(Looper::Event{handler}); + return ndk::ScopedAStatus::ok(); +} - callbacks_.erase( - std::remove_if(callbacks_.begin(), callbacks_.end(), - [&](const CallbackSetting &c) { - if (!c.is_filter_type || t.type == c.type) { - Return<void> ret = c.callback->notifyThrottling(t); - if (!ret.isOk()) { - LOG(ERROR) << "a Thermal callback is dead, removed from " - "callback list."; - return true; - } - return false; - } - return false; - }), - callbacks_.end()); +void Thermal::sendThermalChangedCallback(const Temperature &t) { + ATRACE_CALL(); + std::lock_guard<std::mutex> _lock(thermal_callback_mutex_); + LOG(VERBOSE) << "Sending notification: " + << " Type: " << toString(t.type) << " Name: " << t.name + << " CurrentValue: " << t.value + << " ThrottlingStatus: " << toString(t.throttlingStatus); + + callbacks_.erase(std::remove_if(callbacks_.begin(), callbacks_.end(), + [&](const CallbackSetting &c) { + if (!c.is_filter_type || t.type == c.type) { + ::ndk::ScopedAStatus ret = + c.callback->notifyThrottling(t); + if (!ret.isOk()) { + LOG(ERROR) << "a Thermal callback is dead, removed " + "from callback list."; + return true; + } + return false; + } + return false; + }), + callbacks_.end()); } void Thermal::dumpVirtualSensorInfo(std::ostringstream *dump_buf) { - *dump_buf << "VirtualSensorInfo:" << std::endl; + *dump_buf << "getVirtualSensorInfo:" << std::endl; const auto &map = thermal_helper_.GetSensorInfoMap(); for (const auto &sensor_info_pair : map) { if (sensor_info_pair.second.virtual_sensor_info != nullptr) { @@ -301,11 +245,17 @@ void Thermal::dumpVirtualSensorInfo(std::ostringstream *dump_buf) { *dump_buf << "]" << std::endl; *dump_buf << " Offset: " << sensor_info_pair.second.virtual_sensor_info->offset << std::endl; - *dump_buf << " Trigger Sensor: " - << (sensor_info_pair.second.virtual_sensor_info->trigger_sensor.empty() - ? "N/A" - : sensor_info_pair.second.virtual_sensor_info->trigger_sensor) - << std::endl; + *dump_buf << " Trigger Sensor: "; + if (sensor_info_pair.second.virtual_sensor_info->trigger_sensors.empty()) { + *dump_buf << "N/A" << std::endl; + } else { + for (size_t i = 0; + i < sensor_info_pair.second.virtual_sensor_info->trigger_sensors.size(); i++) { + *dump_buf << sensor_info_pair.second.virtual_sensor_info->trigger_sensors[i] + << " "; + } + *dump_buf << std::endl; + } *dump_buf << " Formula: "; switch (sensor_info_pair.second.virtual_sensor_info->formula) { case FormulaOption::COUNT_THRESHOLD: @@ -331,11 +281,18 @@ void Thermal::dumpVirtualSensorInfo(std::ostringstream *dump_buf) { } void Thermal::dumpThrottlingInfo(std::ostringstream *dump_buf) { - *dump_buf << "Throttling Info:" << std::endl; + *dump_buf << "getThrottlingInfo:" << std::endl; const auto &map = thermal_helper_.GetSensorInfoMap(); const auto &thermal_throttling_status_map = thermal_helper_.GetThermalThrottlingStatusMap(); for (const auto &name_info_pair : map) { + if (name_info_pair.second.throttling_info == nullptr) { + continue; + } if (name_info_pair.second.throttling_info->binded_cdev_info_map.size()) { + if (thermal_throttling_status_map.find(name_info_pair.first) == + thermal_throttling_status_map.end()) { + continue; + } *dump_buf << " Name: " << name_info_pair.first << std::endl; if (thermal_throttling_status_map.at(name_info_pair.first) .pid_power_budget_map.size()) { @@ -458,7 +415,7 @@ void Thermal::dumpThrottlingRequestStatus(std::ostringstream *dump_buf) { if (!thermal_throttling_status_map.size()) { return; } - *dump_buf << "Throttling Request Status " << std::endl; + *dump_buf << "getThrottlingRequestStatus:" << std::endl; for (const auto &thermal_throttling_status_pair : thermal_throttling_status_map) { *dump_buf << " Name: " << thermal_throttling_status_pair.first << std::endl; if (thermal_throttling_status_pair.second.pid_power_budget_map.size()) { @@ -507,7 +464,7 @@ void Thermal::dumpPowerRailInfo(std::ostringstream *dump_buf) { const auto &power_rail_info_map = thermal_helper_.GetPowerRailInfoMap(); const auto &power_status_map = thermal_helper_.GetPowerStatusMap(); - *dump_buf << "Power Rail Info " << std::endl; + *dump_buf << "getPowerRailInfo:" << std::endl; for (const auto &power_rail_pair : power_rail_info_map) { *dump_buf << " Power Rail: " << power_rail_pair.first << std::endl; *dump_buf << " Power Sample Count: " << power_rail_pair.second.power_sample_count @@ -565,176 +522,272 @@ void Thermal::dumpPowerRailInfo(std::ostringstream *dump_buf) { } } -Return<void> Thermal::debug(const hidl_handle &handle, const hidl_vec<hidl_string> &) { - if (handle != nullptr && handle->numFds >= 1) { - int fd = handle->data[0]; - std::ostringstream dump_buf; - - if (!thermal_helper_.isInitializedOk()) { - dump_buf << "ThermalHAL not initialized properly." << std::endl; - } else { - { - hidl_vec<CpuUsage> cpu_usages; - dump_buf << "getCpuUsages:" << std::endl; - if (!thermal_helper_.fillCpuUsages(&cpu_usages)) { - dump_buf << "Failed to get CPU usages." << std::endl; - } +void Thermal::dumpStatsRecord(std::ostringstream *dump_buf, const StatsRecord &stats_record, + std::string_view line_prefix) { + const auto now = boot_clock::now(); + *dump_buf << line_prefix << "Time Since Last Stats Report: " + << std::chrono::duration_cast<std::chrono::minutes>( + now - stats_record.last_stats_report_time) + .count() + << " mins" << std::endl; + *dump_buf << line_prefix << "Time in State ms: ["; + for (const auto &time_in_state : stats_record.time_in_state_ms) { + *dump_buf << time_in_state.count() << " "; + } + *dump_buf << "]" << std::endl; +} + +void Thermal::dumpThermalStats(std::ostringstream *dump_buf) { + *dump_buf << "getThermalStatsInfo:" << std::endl; + *dump_buf << " Sensor Temp Stats Info:" << std::endl; + const auto &sensor_temp_stats_map_ = thermal_helper_.GetSensorTempStatsSnapshot(); + const std::string sensor_temp_stats_line_prefix(" "); + for (const auto &sensor_temp_stats_pair : sensor_temp_stats_map_) { + *dump_buf << " Sensor Name: " << sensor_temp_stats_pair.first << std::endl; + const auto &sensor_temp_stats = sensor_temp_stats_pair.second; + *dump_buf << " Max Temp: " << sensor_temp_stats.max_temp << ", TimeStamp: " + << system_clock::to_time_t(sensor_temp_stats.max_temp_timestamp) << std::endl; + *dump_buf << " Min Temp: " << sensor_temp_stats.min_temp << ", TimeStamp: " + << system_clock::to_time_t(sensor_temp_stats.min_temp_timestamp) << std::endl; + for (const auto &stats_by_threshold : sensor_temp_stats.stats_by_custom_threshold) { + *dump_buf << " Record by Threshold: ["; + for (const auto &threshold : stats_by_threshold.thresholds) { + *dump_buf << threshold << " "; + } + *dump_buf << "]" << std::endl; + if (stats_by_threshold.logging_name.has_value()) { + *dump_buf << " Logging Name: " << stats_by_threshold.logging_name.value() + << std::endl; + } + dumpStatsRecord(dump_buf, stats_by_threshold.stats_record, + sensor_temp_stats_line_prefix); + } - for (const auto &usage : cpu_usages) { - dump_buf << " Name: " << usage.name << " Active: " << usage.active - << " Total: " << usage.total << " IsOnline: " << usage.isOnline - << std::endl; + if (sensor_temp_stats.stats_by_default_threshold.has_value()) { + *dump_buf << " Record by Severity:" << std::endl; + dumpStatsRecord(dump_buf, sensor_temp_stats.stats_by_default_threshold.value(), + sensor_temp_stats_line_prefix); + } + } + *dump_buf << " Sensor Cdev Request Stats Info:" << std::endl; + const auto &sensor_cdev_request_stats_map_ = + thermal_helper_.GetSensorCoolingDeviceRequestStatsSnapshot(); + const std::string sensor_cdev_request_stats_line_prefix(" "); + for (const auto &sensor_cdev_request_stats_pair : sensor_cdev_request_stats_map_) { + *dump_buf << " Sensor Name: " << sensor_cdev_request_stats_pair.first << std::endl; + for (const auto &cdev_request_stats_pair : sensor_cdev_request_stats_pair.second) { + *dump_buf << " Cooling Device Name: " << cdev_request_stats_pair.first << std::endl; + const auto &request_stats = cdev_request_stats_pair.second; + for (const auto &stats_by_threshold : request_stats.stats_by_custom_threshold) { + *dump_buf << " Record by Threshold: ["; + for (const auto &threshold : stats_by_threshold.thresholds) { + *dump_buf << threshold << " "; + } + *dump_buf << "]" << std::endl; + if (stats_by_threshold.logging_name.has_value()) { + *dump_buf << " Logging Name: " << stats_by_threshold.logging_name.value() + << std::endl; } + dumpStatsRecord(dump_buf, stats_by_threshold.stats_record, + sensor_cdev_request_stats_line_prefix); } - { - dump_buf << "getCachedTemperatures:" << std::endl; - boot_clock::time_point now = boot_clock::now(); - const auto &sensor_status_map = thermal_helper_.GetSensorStatusMap(); - for (const auto &sensor_status_pair : sensor_status_map) { - if ((sensor_status_pair.second.thermal_cached.timestamp) == - boot_clock::time_point::min()) { - continue; - } - dump_buf << " Name: " << sensor_status_pair.first - << " CachedValue: " << sensor_status_pair.second.thermal_cached.temp - << " TimeToCache: " - << std::chrono::duration_cast<std::chrono::milliseconds>( - now - sensor_status_pair.second.thermal_cached.timestamp) - .count() - << "ms" << std::endl; + if (request_stats.stats_by_default_threshold.has_value()) { + *dump_buf << " Record by All State" << std::endl; + dumpStatsRecord(dump_buf, request_stats.stats_by_default_threshold.value(), + sensor_cdev_request_stats_line_prefix); + } + } + } +} + +void Thermal::dumpThermalData(int fd) { + std::ostringstream dump_buf; + + if (!thermal_helper_.isInitializedOk()) { + dump_buf << "ThermalHAL not initialized properly." << std::endl; + } else { + const auto &sensor_status_map = thermal_helper_.GetSensorStatusMap(); + { + dump_buf << "getCachedTemperatures:" << std::endl; + boot_clock::time_point now = boot_clock::now(); + for (const auto &sensor_status_pair : sensor_status_map) { + if ((sensor_status_pair.second.thermal_cached.timestamp) == + boot_clock::time_point::min()) { + continue; } + dump_buf << " Name: " << sensor_status_pair.first + << " CachedValue: " << sensor_status_pair.second.thermal_cached.temp + << " TimeToCache: " + << std::chrono::duration_cast<std::chrono::milliseconds>( + now - sensor_status_pair.second.thermal_cached.timestamp) + .count() + << "ms" << std::endl; } - { - const auto &map = thermal_helper_.GetSensorInfoMap(); - dump_buf << "getTemperatures:" << std::endl; - Temperature_1_0 temp_1_0; - for (const auto &name_info_pair : map) { - thermal_helper_.readTemperature(name_info_pair.first, &temp_1_0); - dump_buf << " Type: " - << android::hardware::thermal::V1_0::toString(temp_1_0.type) - << " Name: " << name_info_pair.first - << " CurrentValue: " << temp_1_0.currentValue - << " ThrottlingThreshold: " << temp_1_0.throttlingThreshold - << " ShutdownThreshold: " << temp_1_0.shutdownThreshold - << " VrThrottlingThreshold: " << temp_1_0.vrThrottlingThreshold - << std::endl; + } + { + dump_buf << "getEmulTemperatures:" << std::endl; + for (const auto &sensor_status_pair : sensor_status_map) { + if (sensor_status_pair.second.emul_setting == nullptr) { + continue; } - dump_buf << "getCurrentTemperatures:" << std::endl; - Temperature_2_0 temp_2_0; - for (const auto &name_info_pair : map) { - thermal_helper_.readTemperature(name_info_pair.first, &temp_2_0, nullptr, true); - dump_buf << " Type: " - << android::hardware::thermal::V2_0::toString(temp_2_0.type) - << " Name: " << name_info_pair.first - << " CurrentValue: " << temp_2_0.value << " ThrottlingStatus: " - << android::hardware::thermal::V2_0::toString( - temp_2_0.throttlingStatus) - << std::endl; + dump_buf << " Name: " << sensor_status_pair.first + << " EmulTemp: " << sensor_status_pair.second.emul_setting->emul_temp + << " EmulSeverity: " + << sensor_status_pair.second.emul_setting->emul_severity << std::endl; + } + } + { + const auto &map = thermal_helper_.GetSensorInfoMap(); + dump_buf << "getCurrentTemperatures:" << std::endl; + Temperature temp_2_0; + for (const auto &name_info_pair : map) { + thermal_helper_.readTemperature(name_info_pair.first, &temp_2_0, nullptr, true); + dump_buf << " Type: " << toString(temp_2_0.type) + << " Name: " << name_info_pair.first << " CurrentValue: " << temp_2_0.value + << " ThrottlingStatus: " << toString(temp_2_0.throttlingStatus) + << std::endl; + } + dump_buf << "getTemperatureThresholds:" << std::endl; + for (const auto &name_info_pair : map) { + if (!name_info_pair.second.is_watch) { + continue; } - dump_buf << "getTemperatureThresholds:" << std::endl; - for (const auto &name_info_pair : map) { - if (!name_info_pair.second.is_watch) { - continue; - } - dump_buf << " Type: " - << android::hardware::thermal::V2_0::toString( - name_info_pair.second.type) - << " Name: " << name_info_pair.first; - dump_buf << " hotThrottlingThreshold: ["; - for (size_t i = 0; i < kThrottlingSeverityCount; ++i) { - dump_buf << name_info_pair.second.hot_thresholds[i] << " "; - } - dump_buf << "] coldThrottlingThreshold: ["; - for (size_t i = 0; i < kThrottlingSeverityCount; ++i) { - dump_buf << name_info_pair.second.cold_thresholds[i] << " "; - } - dump_buf << "] vrThrottlingThreshold: " << name_info_pair.second.vr_threshold; - dump_buf << std::endl; + dump_buf << " Type: " << toString(name_info_pair.second.type) + << " Name: " << name_info_pair.first; + dump_buf << " hotThrottlingThreshold: ["; + for (size_t i = 0; i < kThrottlingSeverityCount; ++i) { + dump_buf << name_info_pair.second.hot_thresholds[i] << " "; } - dump_buf << "getHysteresis:" << std::endl; - for (const auto &name_info_pair : map) { - if (!name_info_pair.second.is_watch) { - continue; - } - dump_buf << " Name: " << name_info_pair.first; - dump_buf << " hotHysteresis: ["; - for (size_t i = 0; i < kThrottlingSeverityCount; ++i) { - dump_buf << name_info_pair.second.hot_hysteresis[i] << " "; - } - dump_buf << "] coldHysteresis: ["; - for (size_t i = 0; i < kThrottlingSeverityCount; ++i) { - dump_buf << name_info_pair.second.cold_hysteresis[i] << " "; - } - dump_buf << "]" << std::endl; + dump_buf << "] coldThrottlingThreshold: ["; + for (size_t i = 0; i < kThrottlingSeverityCount; ++i) { + dump_buf << name_info_pair.second.cold_thresholds[i] << " "; } + dump_buf << "] vrThrottlingThreshold: " << name_info_pair.second.vr_threshold; + dump_buf << std::endl; } - { - dump_buf << "getCurrentCoolingDevices:" << std::endl; - hidl_vec<CoolingDevice_2_0> cooling_devices; - if (!thermal_helper_.fillCurrentCoolingDevices(false, CoolingType::CPU, - &cooling_devices)) { - dump_buf << "Failed to getCurrentCoolingDevices." << std::endl; + dump_buf << "getHysteresis:" << std::endl; + for (const auto &name_info_pair : map) { + if (!name_info_pair.second.is_watch) { + continue; } - - for (const auto &c : cooling_devices) { - dump_buf << " Type: " << android::hardware::thermal::V2_0::toString(c.type) - << " Name: " << c.name << " CurrentValue: " << c.value << std::endl; + dump_buf << " Name: " << name_info_pair.first; + dump_buf << " hotHysteresis: ["; + for (size_t i = 0; i < kThrottlingSeverityCount; ++i) { + dump_buf << name_info_pair.second.hot_hysteresis[i] << " "; } - } - { - dump_buf << "Callbacks: Total " << callbacks_.size() << std::endl; - for (const auto &c : callbacks_) { - dump_buf << " IsFilter: " << c.is_filter_type - << " Type: " << android::hardware::thermal::V2_0::toString(c.type) - << std::endl; + dump_buf << "] coldHysteresis: ["; + for (size_t i = 0; i < kThrottlingSeverityCount; ++i) { + dump_buf << name_info_pair.second.cold_hysteresis[i] << " "; } + dump_buf << "]" << std::endl; } - { - dump_buf << "SendCallback" << std::endl; - dump_buf << " Enabled List: "; - const auto &map = thermal_helper_.GetSensorInfoMap(); - for (const auto &name_info_pair : map) { - if (name_info_pair.second.send_cb) { - dump_buf << name_info_pair.first << " "; - } - } - dump_buf << std::endl; + } + { + dump_buf << "getCurrentCoolingDevices:" << std::endl; + std::vector<CoolingDevice> cooling_devices; + if (!thermal_helper_.fillCurrentCoolingDevices(false, CoolingType::CPU, + &cooling_devices)) { + dump_buf << " Failed to getCurrentCoolingDevices." << std::endl; } - { - dump_buf << "SendPowerHint" << std::endl; - dump_buf << " Enabled List: "; - const auto &map = thermal_helper_.GetSensorInfoMap(); - for (const auto &name_info_pair : map) { - if (name_info_pair.second.send_powerhint) { - dump_buf << name_info_pair.first << " "; - } + + for (const auto &c : cooling_devices) { + dump_buf << " Type: " << toString(c.type) << " Name: " << c.name + << " CurrentValue: " << c.value << std::endl; + } + } + { + dump_buf << "getCallbacks:" << std::endl; + dump_buf << " Total: " << callbacks_.size() << std::endl; + for (const auto &c : callbacks_) { + dump_buf << " IsFilter: " << c.is_filter_type << " Type: " << toString(c.type) + << std::endl; + } + } + { + dump_buf << "sendCallback:" << std::endl; + dump_buf << " Enabled List: "; + const auto &map = thermal_helper_.GetSensorInfoMap(); + for (const auto &name_info_pair : map) { + if (name_info_pair.second.send_cb) { + dump_buf << name_info_pair.first << " "; } - dump_buf << std::endl; } - dumpVirtualSensorInfo(&dump_buf); - dumpThrottlingInfo(&dump_buf); - dumpThrottlingRequestStatus(&dump_buf); - dumpPowerRailInfo(&dump_buf); - { - dump_buf << "AIDL Power Hal exist: " << std::boolalpha - << thermal_helper_.isAidlPowerHalExist() << std::endl; - dump_buf << "AIDL Power Hal connected: " << std::boolalpha - << thermal_helper_.isPowerHalConnected() << std::endl; - dump_buf << "AIDL Power Hal Ext connected: " << std::boolalpha - << thermal_helper_.isPowerHalExtConnected() << std::endl; + dump_buf << std::endl; + } + { + dump_buf << "sendPowerHint:" << std::endl; + dump_buf << " Enabled List: "; + const auto &map = thermal_helper_.GetSensorInfoMap(); + for (const auto &name_info_pair : map) { + if (name_info_pair.second.send_powerhint) { + dump_buf << name_info_pair.first << " "; + } } + dump_buf << std::endl; } - std::string buf = dump_buf.str(); - if (!android::base::WriteStringToFd(buf, fd)) { - PLOG(ERROR) << "Failed to dump state to fd"; + dumpVirtualSensorInfo(&dump_buf); + dumpThrottlingInfo(&dump_buf); + dumpThrottlingRequestStatus(&dump_buf); + dumpPowerRailInfo(&dump_buf); + dumpThermalStats(&dump_buf); + { + dump_buf << "getAIDLPowerHalInfo:" << std::endl; + dump_buf << " Exist: " << std::boolalpha << thermal_helper_.isAidlPowerHalExist() + << std::endl; + dump_buf << " Connected: " << std::boolalpha << thermal_helper_.isPowerHalConnected() + << std::endl; + dump_buf << " Ext connected: " << std::boolalpha + << thermal_helper_.isPowerHalExtConnected() << std::endl; } - fsync(fd); } - return Void(); + std::string buf = dump_buf.str(); + if (!::android::base::WriteStringToFd(buf, fd)) { + PLOG(ERROR) << "Failed to dump state to fd"; + } + fsync(fd); +} + +binder_status_t Thermal::dump(int fd, const char **args, uint32_t numArgs) { + if (numArgs == 0 || std::string(args[0]) == "-a") { + dumpThermalData(fd); + return STATUS_OK; + } + + if (std::string(args[0]) == "emul_temp") { + return (numArgs != 3 || !thermal_helper_.emulTemp(std::string(args[1]), std::atof(args[2]))) + ? STATUS_BAD_VALUE + : STATUS_OK; + } else if (std::string(args[0]) == "emul_severity") { + return (numArgs != 3 || + !thermal_helper_.emulSeverity(std::string(args[1]), std::atoi(args[2]))) + ? STATUS_BAD_VALUE + : STATUS_OK; + } else if (std::string(args[0]) == "emul_clear") { + return (numArgs != 2 || !thermal_helper_.emulClear(std::string(args[1]))) ? STATUS_BAD_VALUE + : STATUS_OK; + } + return STATUS_BAD_VALUE; +} + +void Thermal::Looper::addEvent(const Thermal::Looper::Event &e) { + std::unique_lock<std::mutex> lock(mutex_); + events_.push(e); + cv_.notify_all(); +} + +void Thermal::Looper::loop() { + while (true) { + std::unique_lock<std::mutex> lock(mutex_); + cv_.wait(lock, [&] { return !events_.empty(); }); + Event event = events_.front(); + events_.pop(); + lock.unlock(); + event.handler(); + } } } // namespace implementation -} // namespace V2_0 } // namespace thermal } // namespace hardware } // namespace android +} // namespace aidl diff --git a/thermal/Thermal.h b/thermal/Thermal.h index 36e079e7..74449c4e 100644 --- a/thermal/Thermal.h +++ b/thermal/Thermal.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2018 The Android Open Source Project + * Copyright (C) 2022 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. @@ -16,82 +16,105 @@ #pragma once -#include <android/hardware/thermal/2.0/IThermal.h> -#include <android/hardware/thermal/2.0/IThermalChangedCallback.h> -#include <hidl/Status.h> +#include <aidl/android/hardware/thermal/BnThermal.h> #include <mutex> #include <thread> #include "thermal-helper.h" +namespace aidl { namespace android { namespace hardware { namespace thermal { -namespace V2_0 { namespace implementation { -using ::android::sp; -using ::android::hardware::hidl_vec; -using ::android::hardware::Return; -using ::android::hardware::thermal::V2_0::IThermal; -using ::android::hardware::thermal::V2_0::IThermalChangedCallback; - struct CallbackSetting { - CallbackSetting(sp<IThermalChangedCallback> callback, bool is_filter_type, - TemperatureType_2_0 type) + CallbackSetting(std::shared_ptr<IThermalChangedCallback> callback, bool is_filter_type, + TemperatureType type) : callback(std::move(callback)), is_filter_type(is_filter_type), type(type) {} - sp<IThermalChangedCallback> callback; + std::shared_ptr<IThermalChangedCallback> callback; bool is_filter_type; - TemperatureType_2_0 type; + TemperatureType type; }; -class Thermal : public IThermal { +class Thermal : public BnThermal { public: Thermal(); ~Thermal() = default; + ndk::ScopedAStatus getTemperatures(std::vector<Temperature> *_aidl_return) override; + ndk::ScopedAStatus getTemperaturesWithType(TemperatureType type, + std::vector<Temperature> *_aidl_return) override; + + ndk::ScopedAStatus getCoolingDevices(std::vector<CoolingDevice> *_aidl_return) override; + ndk::ScopedAStatus getCoolingDevicesWithType(CoolingType type, + std::vector<CoolingDevice> *_aidl_return) override; - // Disallow copy and assign. - Thermal(const Thermal &) = delete; - void operator=(const Thermal &) = delete; - - // Methods from ::android::hardware::thermal::V1_0::IThermal. - Return<void> getTemperatures(getTemperatures_cb _hidl_cb) override; - Return<void> getCpuUsages(getCpuUsages_cb _hidl_cb) override; - Return<void> getCoolingDevices(getCoolingDevices_cb _hidl_cb) override; - - // Methods from ::android::hardware::thermal::V2_0::IThermal follow. - Return<void> getCurrentTemperatures(bool filterType, TemperatureType_2_0 type, - getCurrentTemperatures_cb _hidl_cb) override; - Return<void> getTemperatureThresholds(bool filterType, TemperatureType_2_0 type, - getTemperatureThresholds_cb _hidl_cb) override; - Return<void> registerThermalChangedCallback( - const sp<IThermalChangedCallback> &callback, bool filterType, TemperatureType_2_0 type, - registerThermalChangedCallback_cb _hidl_cb) override; - Return<void> unregisterThermalChangedCallback( - const sp<IThermalChangedCallback> &callback, - unregisterThermalChangedCallback_cb _hidl_cb) override; - Return<void> getCurrentCoolingDevices(bool filterType, CoolingType type, - getCurrentCoolingDevices_cb _hidl_cb) override; - - // Methods from ::android::hidl::base::V1_0::IBase follow. - Return<void> debug(const hidl_handle &fd, const hidl_vec<hidl_string> &args) override; + ndk::ScopedAStatus getTemperatureThresholds( + std::vector<TemperatureThreshold> *_aidl_return) override; + ndk::ScopedAStatus getTemperatureThresholdsWithType( + TemperatureType type, std::vector<TemperatureThreshold> *_aidl_return) override; + + ndk::ScopedAStatus registerThermalChangedCallback( + const std::shared_ptr<IThermalChangedCallback> &callback) override; + ndk::ScopedAStatus registerThermalChangedCallbackWithType( + const std::shared_ptr<IThermalChangedCallback> &callback, + TemperatureType type) override; + ndk::ScopedAStatus unregisterThermalChangedCallback( + const std::shared_ptr<IThermalChangedCallback> &callback) override; + binder_status_t dump(int fd, const char **args, uint32_t numArgs) override; // Helper function for calling callbacks - void sendThermalChangedCallback(const Temperature_2_0 &t); + void sendThermalChangedCallback(const Temperature &t); private: + class Looper { + public: + struct Event { + std::function<void()> handler; + }; + + Looper() { + thread_ = std::thread([&] { loop(); }); + } + void addEvent(const Event &e); + + private: + std::condition_variable cv_; + std::queue<Event> events_; + std::mutex mutex_; + std::thread thread_; + + void loop(); + }; + ThermalHelper thermal_helper_; + std::mutex thermal_callback_mutex_; + std::vector<CallbackSetting> callbacks_; + Looper looper_; + + ndk::ScopedAStatus getFilteredTemperatures(bool filterType, TemperatureType type, + std::vector<Temperature> *_aidl_return); + ndk::ScopedAStatus getFilteredCoolingDevices(bool filterType, CoolingType type, + std::vector<CoolingDevice> *_aidl_return); + ndk::ScopedAStatus getFilteredTemperatureThresholds( + bool filterType, TemperatureType type, std::vector<TemperatureThreshold> *_aidl_return); + ndk::ScopedAStatus registerThermalChangedCallback( + const std::shared_ptr<IThermalChangedCallback> &callback, bool filterType, + TemperatureType type); + void dumpVirtualSensorInfo(std::ostringstream *dump_buf); void dumpThrottlingInfo(std::ostringstream *dump_buf); void dumpThrottlingRequestStatus(std::ostringstream *dump_buf); void dumpPowerRailInfo(std::ostringstream *dump_buf); - std::mutex thermal_callback_mutex_; - std::vector<CallbackSetting> callbacks_; + void dumpStatsRecord(std::ostringstream *dump_buf, const StatsRecord &stats_record, + std::string_view line_prefix); + void dumpThermalStats(std::ostringstream *dump_buf); + void dumpThermalData(int fd); }; } // namespace implementation -} // namespace V2_0 } // namespace thermal } // namespace hardware } // namespace android +} // namespace aidl diff --git a/thermal/android.hardware.thermal@2.0-service.pixel.rc b/thermal/android.hardware.thermal-service.pixel.rc index 0e23bef8..f9f823b8 100644 --- a/thermal/android.hardware.thermal@2.0-service.pixel.rc +++ b/thermal/android.hardware.thermal-service.pixel.rc @@ -4,11 +4,9 @@ on property:vendor.thermal.link_ready=1 trigger enable-thermal-hal on enable-thermal-hal - start vendor.thermal-hal-2-0 + restart vendor.thermal-hal -service vendor.thermal-hal-2-0 /vendor/bin/hw/android.hardware.thermal@2.0-service.pixel - interface android.hardware.thermal@1.0::IThermal default - interface android.hardware.thermal@2.0::IThermal default +service vendor.thermal-hal /vendor/bin/hw/android.hardware.thermal-service.pixel class hal user system group system diff --git a/thermal/android.hardware.thermal-service.pixel.xml b/thermal/android.hardware.thermal-service.pixel.xml new file mode 100644 index 00000000..bdee7446 --- /dev/null +++ b/thermal/android.hardware.thermal-service.pixel.xml @@ -0,0 +1,7 @@ +<manifest version="1.0" type="device"> + <hal format="aidl"> + <name>android.hardware.thermal</name> + <version>1</version> + <fqname>IThermal/default</fqname> + </hal> +</manifest> diff --git a/thermal/android.hardware.thermal@2.0-service.pixel.xml b/thermal/android.hardware.thermal@2.0-service.pixel.xml deleted file mode 100644 index bcd6344b..00000000 --- a/thermal/android.hardware.thermal@2.0-service.pixel.xml +++ /dev/null @@ -1,12 +0,0 @@ -<manifest version="1.0" type="device"> - <hal format="hidl"> - <name>android.hardware.thermal</name> - <transport>hwbinder</transport> - <version>1.0</version> - <version>2.0</version> - <interface> - <name>IThermal</name> - <instance>default</instance> - </interface> - </hal> -</manifest> diff --git a/thermal/device.mk b/thermal/device.mk index bf150cdf..1d71d312 100644 --- a/thermal/device.mk +++ b/thermal/device.mk @@ -1,12 +1,5 @@ -# Thermal HAL -SOONG_CONFIG_NAMESPACES += thermal_hal_feature -SOONG_CONFIG_thermal_hal_feature += \ - pid \ - -SOONG_CONFIG_thermal_hal_feature_pid ?= apply_1_0 - PRODUCT_PACKAGES += \ - android.hardware.thermal@2.0-service.pixel + android.hardware.thermal-service.pixel # Thermal utils PRODUCT_PACKAGES += \ diff --git a/thermal/pid_1_0/Thermal.cpp b/thermal/pid_1_0/Thermal.cpp deleted file mode 100644 index 2f41445f..00000000 --- a/thermal/pid_1_0/Thermal.cpp +++ /dev/null @@ -1,740 +0,0 @@ -/* - * Copyright (C) 2018 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 ATRACE_TAG (ATRACE_TAG_THERMAL | ATRACE_TAG_HAL) - -#include "Thermal.h" - -#include <android-base/file.h> -#include <android-base/logging.h> -#include <hidl/HidlTransportSupport.h> -#include <utils/Trace.h> - -#include <cerrno> -#include <mutex> -#include <string> - -#include "thermal-helper.h" - -namespace android { -namespace hardware { -namespace thermal { -namespace V2_0 { -namespace implementation { - -namespace { - -using ::android::hardware::interfacesEqual; -using ::android::hardware::thermal::V1_0::ThermalStatus; -using ::android::hardware::thermal::V1_0::ThermalStatusCode; - -template <typename T, typename U> -Return<void> setFailureAndCallback(T _hidl_cb, hidl_vec<U> data, std::string_view debug_msg) { - ThermalStatus status; - status.code = ThermalStatusCode::FAILURE; - status.debugMessage = debug_msg.data(); - _hidl_cb(status, data); - return Void(); -} - -template <typename T, typename U> -Return<void> setInitFailureAndCallback(T _hidl_cb, hidl_vec<U> data) { - return setFailureAndCallback(_hidl_cb, data, "Failure initializing thermal HAL"); -} - -} // namespace - -// On init we will spawn a thread which will continually watch for -// throttling. When throttling is seen, if we have a callback registered -// the thread will call notifyThrottling() else it will log the dropped -// throttling event and do nothing. The thread is only killed when -// Thermal() is killed. -Thermal::Thermal() - : thermal_helper_( - std::bind(&Thermal::sendThermalChangedCallback, this, std::placeholders::_1)) {} - -// Methods from ::android::hardware::thermal::V1_0::IThermal. -Return<void> Thermal::getTemperatures(getTemperatures_cb _hidl_cb) { - ThermalStatus status; - status.code = ThermalStatusCode::SUCCESS; - hidl_vec<Temperature_1_0> temperatures; - - if (!thermal_helper_.isInitializedOk()) { - LOG(ERROR) << "ThermalHAL not initialized properly."; - return setInitFailureAndCallback(_hidl_cb, temperatures); - } - - if (!thermal_helper_.fillTemperatures(&temperatures)) { - return setFailureAndCallback(_hidl_cb, temperatures, "Failed to read thermal sensors."); - } - - _hidl_cb(status, temperatures); - return Void(); -} - -Return<void> Thermal::getCpuUsages(getCpuUsages_cb _hidl_cb) { - ThermalStatus status; - status.code = ThermalStatusCode::SUCCESS; - hidl_vec<CpuUsage> cpu_usages; - - if (!thermal_helper_.isInitializedOk()) { - return setInitFailureAndCallback(_hidl_cb, cpu_usages); - } - - if (!thermal_helper_.fillCpuUsages(&cpu_usages)) { - return setFailureAndCallback(_hidl_cb, cpu_usages, "Failed to get CPU usages."); - } - - _hidl_cb(status, cpu_usages); - return Void(); -} - -Return<void> Thermal::getCoolingDevices(getCoolingDevices_cb _hidl_cb) { - ThermalStatus status; - status.code = ThermalStatusCode::SUCCESS; - hidl_vec<CoolingDevice_1_0> cooling_devices; - - if (!thermal_helper_.isInitializedOk()) { - return setInitFailureAndCallback(_hidl_cb, cooling_devices); - } - _hidl_cb(status, cooling_devices); - return Void(); -} - -Return<void> Thermal::getCurrentTemperatures(bool filterType, TemperatureType_2_0 type, - getCurrentTemperatures_cb _hidl_cb) { - ThermalStatus status; - status.code = ThermalStatusCode::SUCCESS; - hidl_vec<Temperature_2_0> temperatures; - - if (!thermal_helper_.isInitializedOk()) { - LOG(ERROR) << "ThermalHAL not initialized properly."; - return setInitFailureAndCallback(_hidl_cb, temperatures); - } - - if (!thermal_helper_.fillCurrentTemperatures(filterType, false, type, &temperatures)) { - return setFailureAndCallback(_hidl_cb, temperatures, "Failed to read thermal sensors."); - } - - _hidl_cb(status, temperatures); - return Void(); -} - -Return<void> Thermal::getTemperatureThresholds(bool filterType, TemperatureType_2_0 type, - getTemperatureThresholds_cb _hidl_cb) { - ThermalStatus status; - status.code = ThermalStatusCode::SUCCESS; - hidl_vec<TemperatureThreshold> temperatures; - - if (!thermal_helper_.isInitializedOk()) { - LOG(ERROR) << "ThermalHAL not initialized properly."; - return setInitFailureAndCallback(_hidl_cb, temperatures); - } - - if (!thermal_helper_.fillTemperatureThresholds(filterType, type, &temperatures)) { - return setFailureAndCallback(_hidl_cb, temperatures, "Failed to read thermal sensors."); - } - - _hidl_cb(status, temperatures); - return Void(); -} - -Return<void> Thermal::getCurrentCoolingDevices(bool filterType, CoolingType type, - getCurrentCoolingDevices_cb _hidl_cb) { - ThermalStatus status; - status.code = ThermalStatusCode::SUCCESS; - hidl_vec<CoolingDevice_2_0> cooling_devices; - - if (!thermal_helper_.isInitializedOk()) { - LOG(ERROR) << "ThermalHAL not initialized properly."; - return setInitFailureAndCallback(_hidl_cb, cooling_devices); - } - - if (!thermal_helper_.fillCurrentCoolingDevices(filterType, type, &cooling_devices)) { - return setFailureAndCallback(_hidl_cb, cooling_devices, "Failed to read cooling devices."); - } - - _hidl_cb(status, cooling_devices); - return Void(); -} - -Return<void> Thermal::registerThermalChangedCallback(const sp<IThermalChangedCallback> &callback, - bool filterType, TemperatureType_2_0 type, - registerThermalChangedCallback_cb _hidl_cb) { - ThermalStatus status; - hidl_vec<Temperature_2_0> temperatures; - - ATRACE_CALL(); - if (callback == nullptr) { - status.code = ThermalStatusCode::FAILURE; - status.debugMessage = "Invalid nullptr callback"; - LOG(ERROR) << status.debugMessage; - _hidl_cb(status); - return Void(); - } else { - status.code = ThermalStatusCode::SUCCESS; - } - std::lock_guard<std::mutex> _lock(thermal_callback_mutex_); - if (std::any_of(callbacks_.begin(), callbacks_.end(), [&](const CallbackSetting &c) { - return interfacesEqual(c.callback, callback); - })) { - status.code = ThermalStatusCode::FAILURE; - status.debugMessage = "Same callback registered already"; - LOG(ERROR) << status.debugMessage; - } else { - callbacks_.emplace_back(callback, filterType, type); - LOG(INFO) << "a callback has been registered to ThermalHAL, isFilter: " << filterType - << " Type: " << android::hardware::thermal::V2_0::toString(type); - } - _hidl_cb(status); - - // Send notification right away after thermal callback registration - if (thermal_helper_.fillCurrentTemperatures(filterType, true, type, &temperatures)) { - for (const auto &t : temperatures) { - if (!filterType || t.type == type) { - LOG(INFO) << "Sending notification: " - << " Type: " << android::hardware::thermal::V2_0::toString(t.type) - << " Name: " << t.name << " CurrentValue: " << t.value - << " ThrottlingStatus: " - << android::hardware::thermal::V2_0::toString(t.throttlingStatus); - callback->notifyThrottling(t); - } - } - } - - return Void(); -} - -Return<void> Thermal::unregisterThermalChangedCallback( - const sp<IThermalChangedCallback> &callback, unregisterThermalChangedCallback_cb _hidl_cb) { - ThermalStatus status; - if (callback == nullptr) { - status.code = ThermalStatusCode::FAILURE; - status.debugMessage = "Invalid nullptr callback"; - LOG(ERROR) << status.debugMessage; - _hidl_cb(status); - return Void(); - } else { - status.code = ThermalStatusCode::SUCCESS; - } - bool removed = false; - std::lock_guard<std::mutex> _lock(thermal_callback_mutex_); - callbacks_.erase( - std::remove_if( - callbacks_.begin(), callbacks_.end(), - [&](const CallbackSetting &c) { - if (interfacesEqual(c.callback, callback)) { - LOG(INFO) - << "a callback has been unregistered to ThermalHAL, isFilter: " - << c.is_filter_type << " Type: " - << android::hardware::thermal::V2_0::toString(c.type); - removed = true; - return true; - } - return false; - }), - callbacks_.end()); - if (!removed) { - status.code = ThermalStatusCode::FAILURE; - status.debugMessage = "The callback was not registered before"; - LOG(ERROR) << status.debugMessage; - } - _hidl_cb(status); - return Void(); -} - -void Thermal::sendThermalChangedCallback(const Temperature_2_0 &t) { - ATRACE_CALL(); - std::lock_guard<std::mutex> _lock(thermal_callback_mutex_); - LOG(VERBOSE) << "Sending notification: " - << " Type: " << android::hardware::thermal::V2_0::toString(t.type) - << " Name: " << t.name << " CurrentValue: " << t.value << " ThrottlingStatus: " - << android::hardware::thermal::V2_0::toString(t.throttlingStatus); - - callbacks_.erase( - std::remove_if(callbacks_.begin(), callbacks_.end(), - [&](const CallbackSetting &c) { - if (!c.is_filter_type || t.type == c.type) { - Return<void> ret = c.callback->notifyThrottling(t); - if (!ret.isOk()) { - LOG(ERROR) << "a Thermal callback is dead, removed from " - "callback list."; - return true; - } - return false; - } - return false; - }), - callbacks_.end()); -} - -void Thermal::dumpVirtualSensorInfo(std::ostringstream *dump_buf) { - *dump_buf << "VirtualSensorInfo:" << std::endl; - const auto &map = thermal_helper_.GetSensorInfoMap(); - for (const auto &sensor_info_pair : map) { - if (sensor_info_pair.second.virtual_sensor_info != nullptr) { - *dump_buf << " Name: " << sensor_info_pair.first << std::endl; - *dump_buf << " LinkedSensorName: ["; - for (size_t i = 0; - i < sensor_info_pair.second.virtual_sensor_info->linked_sensors.size(); i++) { - *dump_buf << sensor_info_pair.second.virtual_sensor_info->linked_sensors[i] << " "; - } - *dump_buf << "]" << std::endl; - *dump_buf << " LinkedSensorCoefficient: ["; - for (size_t i = 0; i < sensor_info_pair.second.virtual_sensor_info->coefficients.size(); - i++) { - *dump_buf << sensor_info_pair.second.virtual_sensor_info->coefficients[i] << " "; - } - *dump_buf << "]" << std::endl; - *dump_buf << " Offset: " << sensor_info_pair.second.virtual_sensor_info->offset - << std::endl; - *dump_buf << " Trigger Sensor: " - << (sensor_info_pair.second.virtual_sensor_info->trigger_sensor.empty() - ? "N/A" - : sensor_info_pair.second.virtual_sensor_info->trigger_sensor) - << std::endl; - *dump_buf << " Formula: "; - switch (sensor_info_pair.second.virtual_sensor_info->formula) { - case FormulaOption::COUNT_THRESHOLD: - *dump_buf << "COUNT_THRESHOLD"; - break; - case FormulaOption::WEIGHTED_AVG: - *dump_buf << "WEIGHTED_AVG"; - break; - case FormulaOption::MAXIMUM: - *dump_buf << "MAXIMUM"; - break; - case FormulaOption::MINIMUM: - *dump_buf << "MINIMUM"; - break; - default: - *dump_buf << "NONE"; - break; - } - - *dump_buf << std::endl; - } - } -} - -void Thermal::dumpThrottlingInfo(std::ostringstream *dump_buf) { - *dump_buf << "Throttling Info:" << std::endl; - const auto &map = thermal_helper_.GetSensorInfoMap(); - const auto &thermal_throttling_status_map = thermal_helper_.GetThermalThrottlingStatusMap(); - for (const auto &name_info_pair : map) { - if (name_info_pair.second.throttling_info->binded_cdev_info_map.size()) { - *dump_buf << " Name: " << name_info_pair.first << std::endl; - if (thermal_throttling_status_map.at(name_info_pair.first) - .pid_power_budget_map.size()) { - *dump_buf << " PID Info:" << std::endl; - *dump_buf << " K_po: ["; - for (size_t i = 0; i < kThrottlingSeverityCount; ++i) { - *dump_buf << name_info_pair.second.throttling_info->k_po[i] << " "; - } - *dump_buf << "]" << std::endl; - *dump_buf << " K_pu: ["; - for (size_t i = 0; i < kThrottlingSeverityCount; ++i) { - *dump_buf << name_info_pair.second.throttling_info->k_pu[i] << " "; - } - *dump_buf << "]" << std::endl; - *dump_buf << " K_i: ["; - for (size_t i = 0; i < kThrottlingSeverityCount; ++i) { - *dump_buf << name_info_pair.second.throttling_info->k_i[i] << " "; - } - *dump_buf << "]" << std::endl; - *dump_buf << " K_d: ["; - for (size_t i = 0; i < kThrottlingSeverityCount; ++i) { - *dump_buf << name_info_pair.second.throttling_info->k_d[i] << " "; - } - *dump_buf << "]" << std::endl; - *dump_buf << " i_max: ["; - for (size_t i = 0; i < kThrottlingSeverityCount; ++i) { - *dump_buf << name_info_pair.second.throttling_info->i_max[i] << " "; - } - *dump_buf << "]" << std::endl; - *dump_buf << " max_alloc_power: ["; - for (size_t i = 0; i < kThrottlingSeverityCount; ++i) { - *dump_buf << name_info_pair.second.throttling_info->max_alloc_power[i] << " "; - } - *dump_buf << "]" << std::endl; - *dump_buf << " min_alloc_power: ["; - for (size_t i = 0; i < kThrottlingSeverityCount; ++i) { - *dump_buf << name_info_pair.second.throttling_info->min_alloc_power[i] << " "; - } - *dump_buf << "]" << std::endl; - *dump_buf << " s_power: ["; - for (size_t i = 0; i < kThrottlingSeverityCount; ++i) { - *dump_buf << name_info_pair.second.throttling_info->s_power[i] << " "; - } - *dump_buf << "]" << std::endl; - *dump_buf << " i_cutoff: ["; - for (size_t i = 0; i < kThrottlingSeverityCount; ++i) { - *dump_buf << name_info_pair.second.throttling_info->i_cutoff[i] << " "; - } - *dump_buf << "]" << std::endl; - } - *dump_buf << " Binded CDEV Info:" << std::endl; - for (const auto &binded_cdev_info_pair : - name_info_pair.second.throttling_info->binded_cdev_info_map) { - *dump_buf << " Cooling device name: " << binded_cdev_info_pair.first << std::endl; - if (thermal_throttling_status_map.at(name_info_pair.first) - .pid_power_budget_map.size()) { - *dump_buf << " WeightForPID: ["; - for (size_t i = 0; i < kThrottlingSeverityCount; ++i) { - *dump_buf << binded_cdev_info_pair.second.cdev_weight_for_pid[i] << " "; - } - *dump_buf << "]" << std::endl; - } - *dump_buf << " Ceiling: ["; - for (size_t i = 0; i < kThrottlingSeverityCount; ++i) { - *dump_buf << binded_cdev_info_pair.second.cdev_ceiling[i] << " "; - } - *dump_buf << "]" << std::endl; - *dump_buf << " Hard limit: ["; - for (size_t i = 0; i < kThrottlingSeverityCount; ++i) { - *dump_buf << binded_cdev_info_pair.second.limit_info[i] << " "; - } - *dump_buf << "]" << std::endl; - - if (!binded_cdev_info_pair.second.power_rail.empty()) { - *dump_buf << " Binded power rail: " - << binded_cdev_info_pair.second.power_rail << std::endl; - *dump_buf << " Power threshold: ["; - for (size_t i = 0; i < kThrottlingSeverityCount; ++i) { - *dump_buf << binded_cdev_info_pair.second.power_thresholds[i] << " "; - } - *dump_buf << "]" << std::endl; - *dump_buf << " Floor with PowerLink: ["; - for (size_t i = 0; i < kThrottlingSeverityCount; ++i) { - *dump_buf << binded_cdev_info_pair.second.cdev_floor_with_power_link[i] - << " "; - } - *dump_buf << "]" << std::endl; - *dump_buf << " Release logic: "; - switch (binded_cdev_info_pair.second.release_logic) { - case ReleaseLogic::INCREASE: - *dump_buf << "INCREASE"; - break; - case ReleaseLogic::DECREASE: - *dump_buf << "DECREASE"; - break; - case ReleaseLogic::STEPWISE: - *dump_buf << "STEPWISE"; - break; - case ReleaseLogic::RELEASE_TO_FLOOR: - *dump_buf << "RELEASE_TO_FLOOR"; - break; - default: - *dump_buf << "NONE"; - break; - } - *dump_buf << std::endl; - *dump_buf << " high_power_check: " << std::boolalpha - << binded_cdev_info_pair.second.high_power_check << std::endl; - *dump_buf << " throttling_with_power_link: " << std::boolalpha - << binded_cdev_info_pair.second.throttling_with_power_link - << std::endl; - } - } - } - } -} - -void Thermal::dumpThrottlingRequestStatus(std::ostringstream *dump_buf) { - const auto &thermal_throttling_status_map = thermal_helper_.GetThermalThrottlingStatusMap(); - if (!thermal_throttling_status_map.size()) { - return; - } - *dump_buf << "Throttling Request Status " << std::endl; - for (const auto &thermal_throttling_status_pair : thermal_throttling_status_map) { - *dump_buf << " Name: " << thermal_throttling_status_pair.first << std::endl; - if (thermal_throttling_status_pair.second.pid_power_budget_map.size()) { - *dump_buf << " power budget request state" << std::endl; - for (const auto &request_pair : - thermal_throttling_status_pair.second.pid_power_budget_map) { - *dump_buf << " " << request_pair.first << ": " << request_pair.second - << std::endl; - } - } - if (thermal_throttling_status_pair.second.pid_cdev_request_map.size()) { - *dump_buf << " pid cdev request state" << std::endl; - for (const auto &request_pair : - thermal_throttling_status_pair.second.pid_cdev_request_map) { - *dump_buf << " " << request_pair.first << ": " << request_pair.second - << std::endl; - } - } - if (thermal_throttling_status_pair.second.hardlimit_cdev_request_map.size()) { - *dump_buf << " hard limit cdev request state" << std::endl; - for (const auto &request_pair : - thermal_throttling_status_pair.second.hardlimit_cdev_request_map) { - *dump_buf << " " << request_pair.first << ": " << request_pair.second - << std::endl; - } - } - if (thermal_throttling_status_pair.second.throttling_release_map.size()) { - *dump_buf << " cdev release state" << std::endl; - for (const auto &request_pair : - thermal_throttling_status_pair.second.throttling_release_map) { - *dump_buf << " " << request_pair.first << ": " << request_pair.second - << std::endl; - } - } - if (thermal_throttling_status_pair.second.cdev_status_map.size()) { - *dump_buf << " cdev request state" << std::endl; - for (const auto &request_pair : thermal_throttling_status_pair.second.cdev_status_map) { - *dump_buf << " " << request_pair.first << ": " << request_pair.second - << std::endl; - } - } - } -} - -void Thermal::dumpPowerRailInfo(std::ostringstream *dump_buf) { - const auto &power_rail_info_map = thermal_helper_.GetPowerRailInfoMap(); - const auto &power_status_map = thermal_helper_.GetPowerStatusMap(); - - *dump_buf << "Power Rail Info " << std::endl; - for (const auto &power_rail_pair : power_rail_info_map) { - *dump_buf << " Power Rail: " << power_rail_pair.first << std::endl; - *dump_buf << " Power Sample Count: " << power_rail_pair.second.power_sample_count - << std::endl; - *dump_buf << " Power Sample Delay: " << power_rail_pair.second.power_sample_delay.count() - << std::endl; - if (power_status_map.count(power_rail_pair.first)) { - auto power_history = power_status_map.at(power_rail_pair.first).power_history; - *dump_buf << " Last Updated AVG Power: " - << power_status_map.at(power_rail_pair.first).last_updated_avg_power << " mW" - << std::endl; - if (power_rail_pair.second.virtual_power_rail_info != nullptr) { - *dump_buf << " Formula="; - switch (power_rail_pair.second.virtual_power_rail_info->formula) { - case FormulaOption::COUNT_THRESHOLD: - *dump_buf << "COUNT_THRESHOLD"; - break; - case FormulaOption::WEIGHTED_AVG: - *dump_buf << "WEIGHTED_AVG"; - break; - case FormulaOption::MAXIMUM: - *dump_buf << "MAXIMUM"; - break; - case FormulaOption::MINIMUM: - *dump_buf << "MINIMUM"; - break; - default: - *dump_buf << "NONE"; - break; - } - *dump_buf << std::endl; - } - for (size_t i = 0; i < power_history.size(); ++i) { - if (power_rail_pair.second.virtual_power_rail_info != nullptr) { - *dump_buf - << " Linked power rail " - << power_rail_pair.second.virtual_power_rail_info->linked_power_rails[i] - << std::endl; - *dump_buf << " Coefficient=" - << power_rail_pair.second.virtual_power_rail_info->coefficients[i] - << std::endl; - *dump_buf << " Power Samples: "; - } else { - *dump_buf << " Power Samples: "; - } - while (power_history[i].size() > 0) { - const auto power_sample = power_history[i].front(); - power_history[i].pop(); - *dump_buf << "(T=" << power_sample.duration - << ", uWs=" << power_sample.energy_counter << ") "; - } - *dump_buf << std::endl; - } - } - } -} - -Return<void> Thermal::debug(const hidl_handle &handle, const hidl_vec<hidl_string> &) { - if (handle != nullptr && handle->numFds >= 1) { - int fd = handle->data[0]; - std::ostringstream dump_buf; - - if (!thermal_helper_.isInitializedOk()) { - dump_buf << "ThermalHAL not initialized properly." << std::endl; - } else { - { - hidl_vec<CpuUsage> cpu_usages; - dump_buf << "getCpuUsages:" << std::endl; - if (!thermal_helper_.fillCpuUsages(&cpu_usages)) { - dump_buf << "Failed to get CPU usages." << std::endl; - } - - for (const auto &usage : cpu_usages) { - dump_buf << " Name: " << usage.name << " Active: " << usage.active - << " Total: " << usage.total << " IsOnline: " << usage.isOnline - << std::endl; - } - } - { - dump_buf << "getCachedTemperatures:" << std::endl; - boot_clock::time_point now = boot_clock::now(); - const auto &sensor_status_map = thermal_helper_.GetSensorStatusMap(); - for (const auto &sensor_status_pair : sensor_status_map) { - if ((sensor_status_pair.second.thermal_cached.timestamp) == - boot_clock::time_point::min()) { - continue; - } - dump_buf << " Name: " << sensor_status_pair.first - << " CachedValue: " << sensor_status_pair.second.thermal_cached.temp - << " TimeToCache: " - << std::chrono::duration_cast<std::chrono::milliseconds>( - now - sensor_status_pair.second.thermal_cached.timestamp) - .count() - << "ms" << std::endl; - } - } - { - const auto &map = thermal_helper_.GetSensorInfoMap(); - dump_buf << "getTemperatures:" << std::endl; - Temperature_1_0 temp_1_0; - for (const auto &name_info_pair : map) { - thermal_helper_.readTemperature(name_info_pair.first, &temp_1_0); - dump_buf << " Type: " - << android::hardware::thermal::V1_0::toString(temp_1_0.type) - << " Name: " << name_info_pair.first - << " CurrentValue: " << temp_1_0.currentValue - << " ThrottlingThreshold: " << temp_1_0.throttlingThreshold - << " ShutdownThreshold: " << temp_1_0.shutdownThreshold - << " VrThrottlingThreshold: " << temp_1_0.vrThrottlingThreshold - << std::endl; - } - dump_buf << "getCurrentTemperatures:" << std::endl; - Temperature_2_0 temp_2_0; - for (const auto &name_info_pair : map) { - thermal_helper_.readTemperature(name_info_pair.first, &temp_2_0, nullptr, true); - dump_buf << " Type: " - << android::hardware::thermal::V2_0::toString(temp_2_0.type) - << " Name: " << name_info_pair.first - << " CurrentValue: " << temp_2_0.value << " ThrottlingStatus: " - << android::hardware::thermal::V2_0::toString( - temp_2_0.throttlingStatus) - << std::endl; - } - dump_buf << "getTemperatureThresholds:" << std::endl; - for (const auto &name_info_pair : map) { - if (!name_info_pair.second.is_watch) { - continue; - } - dump_buf << " Type: " - << android::hardware::thermal::V2_0::toString( - name_info_pair.second.type) - << " Name: " << name_info_pair.first; - dump_buf << " hotThrottlingThreshold: ["; - for (size_t i = 0; i < kThrottlingSeverityCount; ++i) { - dump_buf << name_info_pair.second.hot_thresholds[i] << " "; - } - dump_buf << "] coldThrottlingThreshold: ["; - for (size_t i = 0; i < kThrottlingSeverityCount; ++i) { - dump_buf << name_info_pair.second.cold_thresholds[i] << " "; - } - dump_buf << "] vrThrottlingThreshold: " << name_info_pair.second.vr_threshold; - dump_buf << std::endl; - } - dump_buf << "getHysteresis:" << std::endl; - for (const auto &name_info_pair : map) { - if (!name_info_pair.second.is_watch) { - continue; - } - dump_buf << " Name: " << name_info_pair.first; - dump_buf << " hotHysteresis: ["; - for (size_t i = 0; i < kThrottlingSeverityCount; ++i) { - dump_buf << name_info_pair.second.hot_hysteresis[i] << " "; - } - dump_buf << "] coldHysteresis: ["; - for (size_t i = 0; i < kThrottlingSeverityCount; ++i) { - dump_buf << name_info_pair.second.cold_hysteresis[i] << " "; - } - dump_buf << "]" << std::endl; - } - } - { - dump_buf << "getCurrentCoolingDevices:" << std::endl; - hidl_vec<CoolingDevice_2_0> cooling_devices; - if (!thermal_helper_.fillCurrentCoolingDevices(false, CoolingType::CPU, - &cooling_devices)) { - dump_buf << "Failed to getCurrentCoolingDevices." << std::endl; - } - - for (const auto &c : cooling_devices) { - dump_buf << " Type: " << android::hardware::thermal::V2_0::toString(c.type) - << " Name: " << c.name << " CurrentValue: " << c.value << std::endl; - } - } - { - dump_buf << "Callbacks: Total " << callbacks_.size() << std::endl; - for (const auto &c : callbacks_) { - dump_buf << " IsFilter: " << c.is_filter_type - << " Type: " << android::hardware::thermal::V2_0::toString(c.type) - << std::endl; - } - } - { - dump_buf << "SendCallback" << std::endl; - dump_buf << " Enabled List: "; - const auto &map = thermal_helper_.GetSensorInfoMap(); - for (const auto &name_info_pair : map) { - if (name_info_pair.second.send_cb) { - dump_buf << name_info_pair.first << " "; - } - } - dump_buf << std::endl; - } - { - dump_buf << "SendPowerHint" << std::endl; - dump_buf << " Enabled List: "; - const auto &map = thermal_helper_.GetSensorInfoMap(); - for (const auto &name_info_pair : map) { - if (name_info_pair.second.send_powerhint) { - dump_buf << name_info_pair.first << " "; - } - } - dump_buf << std::endl; - } - dumpVirtualSensorInfo(&dump_buf); - dumpThrottlingInfo(&dump_buf); - dumpThrottlingRequestStatus(&dump_buf); - dumpPowerRailInfo(&dump_buf); - { - dump_buf << "AIDL Power Hal exist: " << std::boolalpha - << thermal_helper_.isAidlPowerHalExist() << std::endl; - dump_buf << "AIDL Power Hal connected: " << std::boolalpha - << thermal_helper_.isPowerHalConnected() << std::endl; - dump_buf << "AIDL Power Hal Ext connected: " << std::boolalpha - << thermal_helper_.isPowerHalExtConnected() << std::endl; - } - } - std::string buf = dump_buf.str(); - if (!android::base::WriteStringToFd(buf, fd)) { - PLOG(ERROR) << "Failed to dump state to fd"; - } - fsync(fd); - } - return Void(); -} - -} // namespace implementation -} // namespace V2_0 -} // namespace thermal -} // namespace hardware -} // namespace android diff --git a/thermal/pid_1_0/Thermal.h b/thermal/pid_1_0/Thermal.h deleted file mode 100644 index 66a4dd6d..00000000 --- a/thermal/pid_1_0/Thermal.h +++ /dev/null @@ -1,97 +0,0 @@ -/* - * Copyright (C) 2018 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. - */ - -#pragma once - -#include <android/hardware/thermal/2.0/IThermal.h> -#include <android/hardware/thermal/2.0/IThermalChangedCallback.h> -#include <hidl/Status.h> - -#include <mutex> -#include <thread> - -#include "pid_1_0/thermal-helper.h" - -namespace android { -namespace hardware { -namespace thermal { -namespace V2_0 { -namespace implementation { - -using ::android::sp; -using ::android::hardware::hidl_vec; -using ::android::hardware::Return; -using ::android::hardware::thermal::V2_0::IThermal; -using ::android::hardware::thermal::V2_0::IThermalChangedCallback; - -struct CallbackSetting { - CallbackSetting(sp<IThermalChangedCallback> callback, bool is_filter_type, - TemperatureType_2_0 type) - : callback(std::move(callback)), is_filter_type(is_filter_type), type(type) {} - sp<IThermalChangedCallback> callback; - bool is_filter_type; - TemperatureType_2_0 type; -}; - -class Thermal : public IThermal { - public: - Thermal(); - ~Thermal() = default; - - // Disallow copy and assign. - Thermal(const Thermal &) = delete; - void operator=(const Thermal &) = delete; - - // Methods from ::android::hardware::thermal::V1_0::IThermal. - Return<void> getTemperatures(getTemperatures_cb _hidl_cb) override; - Return<void> getCpuUsages(getCpuUsages_cb _hidl_cb) override; - Return<void> getCoolingDevices(getCoolingDevices_cb _hidl_cb) override; - - // Methods from ::android::hardware::thermal::V2_0::IThermal follow. - Return<void> getCurrentTemperatures(bool filterType, TemperatureType_2_0 type, - getCurrentTemperatures_cb _hidl_cb) override; - Return<void> getTemperatureThresholds(bool filterType, TemperatureType_2_0 type, - getTemperatureThresholds_cb _hidl_cb) override; - Return<void> registerThermalChangedCallback( - const sp<IThermalChangedCallback> &callback, bool filterType, TemperatureType_2_0 type, - registerThermalChangedCallback_cb _hidl_cb) override; - Return<void> unregisterThermalChangedCallback( - const sp<IThermalChangedCallback> &callback, - unregisterThermalChangedCallback_cb _hidl_cb) override; - Return<void> getCurrentCoolingDevices(bool filterType, CoolingType type, - getCurrentCoolingDevices_cb _hidl_cb) override; - - // Methods from ::android::hidl::base::V1_0::IBase follow. - Return<void> debug(const hidl_handle &fd, const hidl_vec<hidl_string> &args) override; - - // Helper function for calling callbacks - void sendThermalChangedCallback(const Temperature_2_0 &t); - - private: - ThermalHelper thermal_helper_; - void dumpVirtualSensorInfo(std::ostringstream *dump_buf); - void dumpThrottlingInfo(std::ostringstream *dump_buf); - void dumpThrottlingRequestStatus(std::ostringstream *dump_buf); - void dumpPowerRailInfo(std::ostringstream *dump_buf); - std::mutex thermal_callback_mutex_; - std::vector<CallbackSetting> callbacks_; -}; - -} // namespace implementation -} // namespace V2_0 -} // namespace thermal -} // namespace hardware -} // namespace android diff --git a/thermal/pid_1_0/service.cpp b/thermal/pid_1_0/service.cpp deleted file mode 100644 index 578b23d6..00000000 --- a/thermal/pid_1_0/service.cpp +++ /dev/null @@ -1,66 +0,0 @@ -/* - * Copyright (C) 2018 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. - */ -#include <android-base/logging.h> -#include <hidl/HidlTransportSupport.h> - -#include "Thermal.h" - -constexpr std::string_view kThermalLogTag("pixel-thermal"); - -using ::android::OK; -using ::android::status_t; - -// libhwbinder: -using ::android::hardware::configureRpcThreadpool; -using ::android::hardware::joinRpcThreadpool; - -// Generated HIDL files: -using ::android::hardware::thermal::V2_0::IThermal; -using ::android::hardware::thermal::V2_0::implementation::Thermal; - -static int shutdown() { - LOG(ERROR) << "Pixel Thermal HAL Service is shutting down."; - return 1; -} - -int main(int /* argc */, char ** /* argv */) { - android::base::SetDefaultTag(kThermalLogTag.data()); - status_t status; - android::sp<IThermal> service = nullptr; - - LOG(INFO) << "Pixel Thermal HAL Service 2.0 starting..."; - - service = new Thermal(); - if (service == nullptr) { - LOG(ERROR) << "Error creating an instance of Thermal HAL. Exiting..."; - return shutdown(); - } - - configureRpcThreadpool(1, true /* callerWillJoin */); - - android::hardware::setMinSchedulerPolicy(service, SCHED_NORMAL, -20); - - status = service->registerAsService(); - if (status != OK) { - LOG(ERROR) << "Could not register service for ThermalHAL (" << status << ")"; - return shutdown(); - } - - LOG(INFO) << "Pixel Thermal HAL Service 2.0 started successfully."; - joinRpcThreadpool(); - // We should not get past the joinRpcThreadpool(). - return shutdown(); -} diff --git a/thermal/pid_1_0/thermal-helper.cpp b/thermal/pid_1_0/thermal-helper.cpp deleted file mode 100644 index 14aee56c..00000000 --- a/thermal/pid_1_0/thermal-helper.cpp +++ /dev/null @@ -1,1077 +0,0 @@ -/* - * Copyright (C) 2018 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 ATRACE_TAG (ATRACE_TAG_THERMAL | ATRACE_TAG_HAL) - -#include "thermal-helper.h" - -#include <android-base/file.h> -#include <android-base/logging.h> -#include <android-base/properties.h> -#include <android-base/stringprintf.h> -#include <android-base/strings.h> -#include <utils/Trace.h> - -#include <iterator> -#include <set> -#include <sstream> -#include <thread> -#include <vector> - -namespace android { -namespace hardware { -namespace thermal { -namespace V2_0 { -namespace implementation { - -constexpr std::string_view kCpuOnlineRoot("/sys/devices/system/cpu"); -constexpr std::string_view kThermalSensorsRoot("/sys/devices/virtual/thermal"); -constexpr std::string_view kCpuUsageFile("/proc/stat"); -constexpr std::string_view kCpuOnlineFileSuffix("online"); -constexpr std::string_view kCpuPresentFile("/sys/devices/system/cpu/present"); -constexpr std::string_view kSensorPrefix("thermal_zone"); -constexpr std::string_view kCoolingDevicePrefix("cooling_device"); -constexpr std::string_view kThermalNameFile("type"); -constexpr std::string_view kSensorPolicyFile("policy"); -constexpr std::string_view kSensorTempSuffix("temp"); -constexpr std::string_view kSensorTripPointTempZeroFile("trip_point_0_temp"); -constexpr std::string_view kSensorTripPointHystZeroFile("trip_point_0_hyst"); -constexpr std::string_view kUserSpaceSuffix("user_space"); -constexpr std::string_view kCoolingDeviceCurStateSuffix("cur_state"); -constexpr std::string_view kCoolingDeviceMaxStateSuffix("max_state"); -constexpr std::string_view kCoolingDeviceState2powerSuffix("state2power_table"); -constexpr std::string_view kConfigProperty("vendor.thermal.config"); -constexpr std::string_view kConfigDefaultFileName("thermal_info_config.json"); -constexpr std::string_view kThermalGenlProperty("persist.vendor.enable.thermal.genl"); -constexpr std::string_view kThermalDisabledProperty("vendor.disable.thermal.control"); - -namespace { -using android::base::StringPrintf; - -/* - * Pixel don't offline CPU, so std::thread::hardware_concurrency(); should work. - * However /sys/devices/system/cpu/present is preferred. - * The file is expected to contain single text line with two numbers %d-%d, - * which is a range of available cpu numbers, e.g. 0-7 would mean there - * are 8 cores number from 0 to 7. - * For Android systems this approach is safer than using cpufeatures, see bug - * b/36941727. - */ -static int getNumberOfCores() { - std::string file; - if (!android::base::ReadFileToString(kCpuPresentFile.data(), &file)) { - LOG(ERROR) << "Error reading CPU present file: " << kCpuPresentFile; - return 0; - } - std::vector<std::string> pieces = android::base::Split(file, "-"); - if (pieces.size() != 2) { - LOG(ERROR) << "Error parsing CPU present file content: " << file; - return 0; - } - auto min_core = std::stoul(pieces[0]); - auto max_core = std::stoul(pieces[1]); - if (max_core < min_core) { - LOG(ERROR) << "Error parsing CPU present min and max: " << min_core << " - " << max_core; - return 0; - } - return static_cast<std::size_t>(max_core - min_core + 1); -} -const int kMaxCpus = getNumberOfCores(); - -void parseCpuUsagesFileAndAssignUsages(hidl_vec<CpuUsage> *cpu_usages) { - std::string data; - if (!android::base::ReadFileToString(kCpuUsageFile.data(), &data)) { - LOG(ERROR) << "Error reading CPU usage file: " << kCpuUsageFile; - return; - } - - std::istringstream stat_data(data); - std::string line; - while (std::getline(stat_data, line)) { - if (!line.find("cpu") && isdigit(line[3])) { - // Split the string using spaces. - std::vector<std::string> words = android::base::Split(line, " "); - std::string cpu_name = words[0]; - int cpu_num = std::stoi(cpu_name.substr(3)); - - if (cpu_num < kMaxCpus) { - uint64_t user = std::stoull(words[1]); - uint64_t nice = std::stoull(words[2]); - uint64_t system = std::stoull(words[3]); - uint64_t idle = std::stoull(words[4]); - - // Check if the CPU is online by reading the online file. - std::string cpu_online_path = - StringPrintf("%s/%s/%s", kCpuOnlineRoot.data(), cpu_name.c_str(), - kCpuOnlineFileSuffix.data()); - std::string is_online; - if (!android::base::ReadFileToString(cpu_online_path, &is_online)) { - LOG(ERROR) << "Could not open CPU online file: " << cpu_online_path; - if (cpu_num != 0) { - return; - } - // Some architecture cannot offline cpu0, so assuming it is online - is_online = "1"; - } - is_online = android::base::Trim(is_online); - - (*cpu_usages)[cpu_num].active = user + nice + system; - (*cpu_usages)[cpu_num].total = user + nice + system + idle; - (*cpu_usages)[cpu_num].isOnline = (is_online == "1") ? true : false; - } else { - LOG(ERROR) << "Unexpected CPU number: " << words[0]; - return; - } - } - } -} - -std::unordered_map<std::string, std::string> parseThermalPathMap(std::string_view prefix) { - std::unordered_map<std::string, std::string> path_map; - std::unique_ptr<DIR, int (*)(DIR *)> dir(opendir(kThermalSensorsRoot.data()), closedir); - if (!dir) { - return path_map; - } - - // std::filesystem is not available for vendor yet - // see discussion: aosp/894015 - while (struct dirent *dp = readdir(dir.get())) { - if (dp->d_type != DT_DIR) { - continue; - } - - if (!android::base::StartsWith(dp->d_name, prefix.data())) { - continue; - } - - std::string path = android::base::StringPrintf("%s/%s/%s", kThermalSensorsRoot.data(), - dp->d_name, kThermalNameFile.data()); - std::string name; - if (!android::base::ReadFileToString(path, &name)) { - PLOG(ERROR) << "Failed to read from " << path; - continue; - } - - path_map.emplace( - android::base::Trim(name), - android::base::StringPrintf("%s/%s", kThermalSensorsRoot.data(), dp->d_name)); - } - - return path_map; -} - -} // namespace - -/* - * Populate the sensor_name_to_file_map_ map by walking through the file tree, - * reading the type file and assigning the temp file path to the map. If we do - * not succeed, abort. - */ -ThermalHelper::ThermalHelper(const NotificationCallback &cb) - : thermal_watcher_(new ThermalWatcher( - std::bind(&ThermalHelper::thermalWatcherCallbackFunc, this, std::placeholders::_1))), - cb_(cb) { - const std::string config_path = - "/vendor/etc/" + - android::base::GetProperty(kConfigProperty.data(), kConfigDefaultFileName.data()); - bool thermal_throttling_disabled = - android::base::GetBoolProperty(kThermalDisabledProperty.data(), false); - - is_initialized_ = ParseCoolingDevice(config_path, &cooling_device_info_map_) && - ParseSensorInfo(config_path, &sensor_info_map_); - - if (thermal_throttling_disabled) { - return; - } - - if (!is_initialized_) { - LOG(FATAL) << "Failed to parse thermal configs"; - } - - auto tz_map = parseThermalPathMap(kSensorPrefix.data()); - auto cdev_map = parseThermalPathMap(kCoolingDevicePrefix.data()); - - is_initialized_ = initializeSensorMap(tz_map) && initializeCoolingDevices(cdev_map); - - if (!is_initialized_) { - LOG(FATAL) << "ThermalHAL could not be initialized properly."; - } - - if (!power_files_.registerPowerRailsToWatch(config_path)) { - LOG(FATAL) << "Failed to register power rails"; - } - - for (auto const &name_status_pair : sensor_info_map_) { - sensor_status_map_[name_status_pair.first] = { - .severity = ThrottlingSeverity::NONE, - .prev_hot_severity = ThrottlingSeverity::NONE, - .prev_cold_severity = ThrottlingSeverity::NONE, - .prev_hint_severity = ThrottlingSeverity::NONE, - .last_update_time = boot_clock::time_point::min(), - .thermal_cached = {NAN, boot_clock::time_point::min()}, - }; - - if (name_status_pair.second.throttling_info != nullptr) { - if (!thermal_throttling_.registerThermalThrottling( - name_status_pair.first, name_status_pair.second.throttling_info, - cooling_device_info_map_)) { - LOG(FATAL) << name_status_pair.first << " failed to register thermal throttling"; - } - } - - // Update cooling device max state - for (auto &binded_cdev_pair : - name_status_pair.second.throttling_info->binded_cdev_info_map) { - const auto &cdev_info = cooling_device_info_map_.at(binded_cdev_pair.first); - - for (auto &cdev_ceiling : binded_cdev_pair.second.cdev_ceiling) { - if (cdev_ceiling > cdev_info.max_state) { - if (cdev_ceiling != std::numeric_limits<int>::max()) { - LOG(ERROR) << "Sensor " << name_status_pair.first << "'s " - << binded_cdev_pair.first << " cdev_ceiling:" << cdev_ceiling - << " is higher than max state:" << cdev_info.max_state; - } - cdev_ceiling = cdev_info.max_state; - } - } - } - - if (name_status_pair.second.virtual_sensor_info != nullptr && - !name_status_pair.second.virtual_sensor_info->trigger_sensor.empty() && - name_status_pair.second.is_watch) { - if (sensor_info_map_.count( - name_status_pair.second.virtual_sensor_info->trigger_sensor)) { - sensor_info_map_[name_status_pair.second.virtual_sensor_info->trigger_sensor] - .is_watch = true; - } else { - LOG(FATAL) << name_status_pair.first << "'s trigger sensor: " - << name_status_pair.second.virtual_sensor_info->trigger_sensor - << " is invalid"; - } - } - } - - const bool thermal_genl_enabled = - android::base::GetBoolProperty(kThermalGenlProperty.data(), false); - - std::set<std::string> monitored_sensors; - initializeTrip(tz_map, &monitored_sensors, thermal_genl_enabled); - - if (thermal_genl_enabled) { - thermal_watcher_->registerFilesToWatchNl(monitored_sensors); - } else { - thermal_watcher_->registerFilesToWatch(monitored_sensors); - } - - // Need start watching after status map initialized - is_initialized_ = thermal_watcher_->startWatchingDeviceFiles(); - if (!is_initialized_) { - LOG(FATAL) << "ThermalHAL could not start watching thread properly."; - } - - if (!connectToPowerHal()) { - LOG(ERROR) << "Fail to connect to Power Hal"; - } else { - updateSupportedPowerHints(); - } -} - -bool getThermalZoneTypeById(int tz_id, std::string *type) { - std::string tz_type; - std::string path = - android::base::StringPrintf("%s/%s%d/%s", kThermalSensorsRoot.data(), - kSensorPrefix.data(), tz_id, kThermalNameFile.data()); - LOG(INFO) << "TZ Path: " << path; - if (!::android::base::ReadFileToString(path, &tz_type)) { - LOG(ERROR) << "Failed to read sensor: " << tz_type; - return false; - } - - // Strip the newline. - *type = ::android::base::Trim(tz_type); - LOG(INFO) << "TZ type: " << *type; - return true; -} - -bool ThermalHelper::readCoolingDevice(std::string_view cooling_device, - CoolingDevice_2_0 *out) const { - // Read the file. If the file can't be read temp will be empty string. - std::string data; - - if (!cooling_devices_.readThermalFile(cooling_device, &data)) { - LOG(ERROR) << "readCoolingDevice: failed to read cooling_device: " << cooling_device; - return false; - } - - const CdevInfo &cdev_info = cooling_device_info_map_.at(cooling_device.data()); - const CoolingType &type = cdev_info.type; - - out->type = type; - out->name = cooling_device.data(); - out->value = std::stoi(data); - - return true; -} - -bool ThermalHelper::readTemperature(std::string_view sensor_name, Temperature_1_0 *out) { - // Return fail if the thermal sensor cannot be read. - float temp; - if (!readThermalSensor(sensor_name, &temp, false)) { - LOG(ERROR) << "readTemperature: failed to read sensor: " << sensor_name; - return false; - } - - const SensorInfo &sensor_info = sensor_info_map_.at(sensor_name.data()); - TemperatureType_1_0 type = - (static_cast<int>(sensor_info.type) > static_cast<int>(TemperatureType_1_0::SKIN)) - ? TemperatureType_1_0::UNKNOWN - : static_cast<TemperatureType_1_0>(sensor_info.type); - out->type = type; - out->name = sensor_name.data(); - out->currentValue = temp * sensor_info.multiplier; - out->throttlingThreshold = - sensor_info.hot_thresholds[static_cast<size_t>(ThrottlingSeverity::SEVERE)]; - out->shutdownThreshold = - sensor_info.hot_thresholds[static_cast<size_t>(ThrottlingSeverity::SHUTDOWN)]; - out->vrThrottlingThreshold = sensor_info.vr_threshold; - - return true; -} - -bool ThermalHelper::readTemperature( - std::string_view sensor_name, Temperature_2_0 *out, - std::pair<ThrottlingSeverity, ThrottlingSeverity> *throtting_status, - const bool force_sysfs) { - // Return fail if the thermal sensor cannot be read. - float temp; - - if (!readThermalSensor(sensor_name, &temp, force_sysfs)) { - LOG(ERROR) << "readTemperature: failed to read sensor: " << sensor_name; - return false; - } - - const auto &sensor_info = sensor_info_map_.at(sensor_name.data()); - out->type = sensor_info.type; - out->name = sensor_name.data(); - out->value = temp * sensor_info.multiplier; - - std::pair<ThrottlingSeverity, ThrottlingSeverity> status = - std::make_pair(ThrottlingSeverity::NONE, ThrottlingSeverity::NONE); - // Only update status if the thermal sensor is being monitored - if (sensor_info.is_watch) { - ThrottlingSeverity prev_hot_severity, prev_cold_severity; - { - // reader lock, readTemperature will be called in Binder call and the watcher thread. - std::shared_lock<std::shared_mutex> _lock(sensor_status_map_mutex_); - prev_hot_severity = sensor_status_map_.at(sensor_name.data()).prev_hot_severity; - prev_cold_severity = sensor_status_map_.at(sensor_name.data()).prev_cold_severity; - } - status = getSeverityFromThresholds(sensor_info.hot_thresholds, sensor_info.cold_thresholds, - sensor_info.hot_hysteresis, sensor_info.cold_hysteresis, - prev_hot_severity, prev_cold_severity, out->value); - } - if (throtting_status) { - *throtting_status = status; - } - - out->throttlingStatus = static_cast<size_t>(status.first) > static_cast<size_t>(status.second) - ? status.first - : status.second; - - return true; -} - -bool ThermalHelper::readTemperatureThreshold(std::string_view sensor_name, - TemperatureThreshold *out) const { - // Read the file. If the file can't be read temp will be empty string. - std::string temp; - std::string path; - - if (!sensor_info_map_.count(sensor_name.data())) { - LOG(ERROR) << __func__ << ": sensor not found: " << sensor_name; - return false; - } - - const auto &sensor_info = sensor_info_map_.at(sensor_name.data()); - - out->type = sensor_info.type; - out->name = sensor_name.data(); - out->hotThrottlingThresholds = sensor_info.hot_thresholds; - out->coldThrottlingThresholds = sensor_info.cold_thresholds; - out->vrThrottlingThreshold = sensor_info.vr_threshold; - return true; -} - -void ThermalHelper::updateCoolingDevices(const std::vector<std::string> &updated_cdev) { - int max_state; - - const auto &thermal_throttling_status_map = thermal_throttling_.GetThermalThrottlingStatusMap(); - - for (const auto &target_cdev : updated_cdev) { - max_state = 0; - for (const auto &thermal_throttling_status_pair : thermal_throttling_status_map) { - if (!thermal_throttling_status_pair.second.cdev_status_map.count(target_cdev)) { - continue; - } - const auto state = - thermal_throttling_status_pair.second.cdev_status_map.at(target_cdev); - if (state > max_state) { - max_state = state; - } - } - if (cooling_devices_.writeCdevFile(target_cdev, std::to_string(max_state))) { - LOG(INFO) << "Successfully update cdev " << target_cdev << " sysfs to " << max_state; - } - } -} - -std::pair<ThrottlingSeverity, ThrottlingSeverity> ThermalHelper::getSeverityFromThresholds( - const ThrottlingArray &hot_thresholds, const ThrottlingArray &cold_thresholds, - const ThrottlingArray &hot_hysteresis, const ThrottlingArray &cold_hysteresis, - ThrottlingSeverity prev_hot_severity, ThrottlingSeverity prev_cold_severity, - float value) const { - ThrottlingSeverity ret_hot = ThrottlingSeverity::NONE; - ThrottlingSeverity ret_hot_hysteresis = ThrottlingSeverity::NONE; - ThrottlingSeverity ret_cold = ThrottlingSeverity::NONE; - ThrottlingSeverity ret_cold_hysteresis = ThrottlingSeverity::NONE; - - // Here we want to control the iteration from high to low, and hidl_enum_range doesn't support - // a reverse iterator yet. - for (size_t i = static_cast<size_t>(ThrottlingSeverity::SHUTDOWN); - i > static_cast<size_t>(ThrottlingSeverity::NONE); --i) { - if (!std::isnan(hot_thresholds[i]) && hot_thresholds[i] <= value && - ret_hot == ThrottlingSeverity::NONE) { - ret_hot = static_cast<ThrottlingSeverity>(i); - } - if (!std::isnan(hot_thresholds[i]) && (hot_thresholds[i] - hot_hysteresis[i]) < value && - ret_hot_hysteresis == ThrottlingSeverity::NONE) { - ret_hot_hysteresis = static_cast<ThrottlingSeverity>(i); - } - if (!std::isnan(cold_thresholds[i]) && cold_thresholds[i] >= value && - ret_cold == ThrottlingSeverity::NONE) { - ret_cold = static_cast<ThrottlingSeverity>(i); - } - if (!std::isnan(cold_thresholds[i]) && (cold_thresholds[i] + cold_hysteresis[i]) > value && - ret_cold_hysteresis == ThrottlingSeverity::NONE) { - ret_cold_hysteresis = static_cast<ThrottlingSeverity>(i); - } - } - if (static_cast<size_t>(ret_hot) < static_cast<size_t>(prev_hot_severity)) { - ret_hot = ret_hot_hysteresis; - } - if (static_cast<size_t>(ret_cold) < static_cast<size_t>(prev_cold_severity)) { - ret_cold = ret_cold_hysteresis; - } - - return std::make_pair(ret_hot, ret_cold); -} - -bool ThermalHelper::initializeSensorMap( - const std::unordered_map<std::string, std::string> &path_map) { - for (const auto &sensor_info_pair : sensor_info_map_) { - std::string_view sensor_name = sensor_info_pair.first; - if (sensor_info_pair.second.virtual_sensor_info != nullptr) { - continue; - } - if (!path_map.count(sensor_name.data())) { - LOG(ERROR) << "Could not find " << sensor_name << " in sysfs"; - return false; - } - - std::string path; - if (sensor_info_pair.second.temp_path.empty()) { - path = android::base::StringPrintf("%s/%s", path_map.at(sensor_name.data()).c_str(), - kSensorTempSuffix.data()); - } else { - path = sensor_info_pair.second.temp_path; - } - - if (!thermal_sensors_.addThermalFile(sensor_name, path)) { - LOG(ERROR) << "Could not add " << sensor_name << "to sensors map"; - return false; - } - } - return true; -} - -bool ThermalHelper::initializeCoolingDevices( - const std::unordered_map<std::string, std::string> &path_map) { - for (auto &cooling_device_info_pair : cooling_device_info_map_) { - std::string cooling_device_name = cooling_device_info_pair.first; - if (!path_map.count(cooling_device_name)) { - LOG(ERROR) << "Could not find " << cooling_device_name << " in sysfs"; - return false; - } - // Add cooling device path for thermalHAL to get current state - std::string_view path = path_map.at(cooling_device_name); - std::string read_path; - if (!cooling_device_info_pair.second.read_path.empty()) { - read_path = cooling_device_info_pair.second.read_path.data(); - } else { - read_path = android::base::StringPrintf("%s/%s", path.data(), - kCoolingDeviceCurStateSuffix.data()); - } - if (!cooling_devices_.addThermalFile(cooling_device_name, read_path)) { - LOG(ERROR) << "Could not add " << cooling_device_name - << " read path to cooling device map"; - return false; - } - - std::string state2power_path = android::base::StringPrintf( - "%s/%s", path.data(), kCoolingDeviceState2powerSuffix.data()); - std::string state2power_str; - if (android::base::ReadFileToString(state2power_path, &state2power_str)) { - LOG(INFO) << "Cooling device " << cooling_device_info_pair.first - << " use state2power read from sysfs"; - cooling_device_info_pair.second.state2power.clear(); - - std::stringstream power(state2power_str); - unsigned int power_number; - int i = 0; - while (power >> power_number) { - cooling_device_info_pair.second.state2power.push_back( - static_cast<float>(power_number)); - LOG(INFO) << "Cooling device " << cooling_device_info_pair.first << " state:" << i - << " power: " << power_number; - i++; - } - } - - // Get max cooling device request state - std::string max_state; - std::string max_state_path = android::base::StringPrintf( - "%s/%s", path.data(), kCoolingDeviceMaxStateSuffix.data()); - if (!android::base::ReadFileToString(max_state_path, &max_state)) { - LOG(ERROR) << cooling_device_info_pair.first - << " could not open max state file:" << max_state_path; - cooling_device_info_pair.second.max_state = std::numeric_limits<int>::max(); - } else { - cooling_device_info_pair.second.max_state = std::stoi(android::base::Trim(max_state)); - LOG(INFO) << "Cooling device " << cooling_device_info_pair.first - << " max state: " << cooling_device_info_pair.second.max_state - << " state2power number: " - << cooling_device_info_pair.second.state2power.size(); - if (cooling_device_info_pair.second.state2power.size() > 0 && - static_cast<int>(cooling_device_info_pair.second.state2power.size()) != - (cooling_device_info_pair.second.max_state + 1)) { - LOG(ERROR) << "Invalid state2power number: " - << cooling_device_info_pair.second.state2power.size() - << ", number should be " << cooling_device_info_pair.second.max_state + 1 - << " (max_state + 1)"; - return false; - } - } - - // Add cooling device path for thermalHAL to request state - cooling_device_name = - android::base::StringPrintf("%s_%s", cooling_device_name.c_str(), "w"); - std::string write_path; - if (!cooling_device_info_pair.second.write_path.empty()) { - write_path = cooling_device_info_pair.second.write_path.data(); - } else { - write_path = android::base::StringPrintf("%s/%s", path.data(), - kCoolingDeviceCurStateSuffix.data()); - } - - if (!cooling_devices_.addThermalFile(cooling_device_name, write_path)) { - LOG(ERROR) << "Could not add " << cooling_device_name - << " write path to cooling device map"; - return false; - } - } - return true; -} - -void ThermalHelper::setMinTimeout(SensorInfo *sensor_info) { - sensor_info->polling_delay = kMinPollIntervalMs; - sensor_info->passive_delay = kMinPollIntervalMs; -} - -void ThermalHelper::initializeTrip(const std::unordered_map<std::string, std::string> &path_map, - std::set<std::string> *monitored_sensors, - bool thermal_genl_enabled) { - for (auto &sensor_info : sensor_info_map_) { - if (!sensor_info.second.is_watch || (sensor_info.second.virtual_sensor_info != nullptr)) { - continue; - } - - bool trip_update = false; - std::string_view sensor_name = sensor_info.first; - std::string_view tz_path = path_map.at(sensor_name.data()); - std::string tz_policy; - std::string path = - android::base::StringPrintf("%s/%s", (tz_path.data()), kSensorPolicyFile.data()); - - if (thermal_genl_enabled) { - trip_update = true; - } else { - // Check if thermal zone support uevent notify - if (!android::base::ReadFileToString(path, &tz_policy)) { - LOG(ERROR) << sensor_name << " could not open tz policy file:" << path; - } else { - tz_policy = android::base::Trim(tz_policy); - if (tz_policy != kUserSpaceSuffix) { - LOG(ERROR) << sensor_name << " does not support uevent notify"; - } else { - trip_update = true; - } - } - } - if (trip_update) { - // Update thermal zone trip point - for (size_t i = 0; i < kThrottlingSeverityCount; ++i) { - if (!std::isnan(sensor_info.second.hot_thresholds[i]) && - !std::isnan(sensor_info.second.hot_hysteresis[i])) { - // Update trip_point_0_temp threshold - std::string threshold = std::to_string(static_cast<int>( - sensor_info.second.hot_thresholds[i] / sensor_info.second.multiplier)); - path = android::base::StringPrintf("%s/%s", (tz_path.data()), - kSensorTripPointTempZeroFile.data()); - if (!android::base::WriteStringToFile(threshold, path)) { - LOG(ERROR) << "fail to update " << sensor_name << " trip point: " << path - << " to " << threshold; - trip_update = false; - break; - } - // Update trip_point_0_hyst threshold - threshold = std::to_string(static_cast<int>( - sensor_info.second.hot_hysteresis[i] / sensor_info.second.multiplier)); - path = android::base::StringPrintf("%s/%s", (tz_path.data()), - kSensorTripPointHystZeroFile.data()); - if (!android::base::WriteStringToFile(threshold, path)) { - LOG(ERROR) << "fail to update " << sensor_name << "trip hyst" << threshold - << path; - trip_update = false; - break; - } - break; - } else if (i == kThrottlingSeverityCount - 1) { - LOG(ERROR) << sensor_name << ":all thresholds are NAN"; - trip_update = false; - break; - } - } - monitored_sensors->insert(sensor_info.first); - } - - if (!trip_update) { - LOG(INFO) << "config Sensor: " << sensor_info.first - << " to default polling interval: " << kMinPollIntervalMs.count(); - setMinTimeout(&sensor_info.second); - } - } -} - -bool ThermalHelper::fillTemperatures(hidl_vec<Temperature_1_0> *temperatures) { - std::vector<Temperature_1_0> ret; - for (const auto &name_info_pair : sensor_info_map_) { - Temperature_1_0 temp; - - if (name_info_pair.second.is_hidden) { - continue; - } - - if (readTemperature(name_info_pair.first, &temp)) { - ret.emplace_back(std::move(temp)); - } else { - LOG(ERROR) << __func__ - << ": error reading temperature for sensor: " << name_info_pair.first; - return false; - } - } - *temperatures = ret; - return ret.size() > 0; -} - -bool ThermalHelper::fillCurrentTemperatures(bool filterType, bool filterCallback, - TemperatureType_2_0 type, - hidl_vec<Temperature_2_0> *temperatures) { - std::vector<Temperature_2_0> ret; - for (const auto &name_info_pair : sensor_info_map_) { - Temperature_2_0 temp; - if (name_info_pair.second.is_hidden) { - continue; - } - if (filterType && name_info_pair.second.type != type) { - continue; - } - if (filterCallback && !name_info_pair.second.send_cb) { - continue; - } - if (readTemperature(name_info_pair.first, &temp, nullptr, false)) { - ret.emplace_back(std::move(temp)); - } else { - LOG(ERROR) << __func__ - << ": error reading temperature for sensor: " << name_info_pair.first; - } - } - *temperatures = ret; - return ret.size() > 0; -} - -bool ThermalHelper::fillTemperatureThresholds(bool filterType, TemperatureType_2_0 type, - hidl_vec<TemperatureThreshold> *thresholds) const { - std::vector<TemperatureThreshold> ret; - for (const auto &name_info_pair : sensor_info_map_) { - TemperatureThreshold temp; - if (name_info_pair.second.is_hidden) { - continue; - } - if (filterType && name_info_pair.second.type != type) { - continue; - } - if (readTemperatureThreshold(name_info_pair.first, &temp)) { - ret.emplace_back(std::move(temp)); - } else { - LOG(ERROR) << __func__ << ": error reading temperature threshold for sensor: " - << name_info_pair.first; - return false; - } - } - *thresholds = ret; - return ret.size() > 0; -} - -bool ThermalHelper::fillCurrentCoolingDevices(bool filterType, CoolingType type, - hidl_vec<CoolingDevice_2_0> *cooling_devices) const { - std::vector<CoolingDevice_2_0> ret; - for (const auto &name_info_pair : cooling_device_info_map_) { - CoolingDevice_2_0 value; - if (filterType && name_info_pair.second.type != type) { - continue; - } - if (readCoolingDevice(name_info_pair.first, &value)) { - ret.emplace_back(std::move(value)); - } else { - LOG(ERROR) << __func__ << ": error reading cooling device: " << name_info_pair.first; - return false; - } - } - *cooling_devices = ret; - return ret.size() > 0; -} - -bool ThermalHelper::fillCpuUsages(hidl_vec<CpuUsage> *cpu_usages) const { - cpu_usages->resize(kMaxCpus); - for (int i = 0; i < kMaxCpus; i++) { - (*cpu_usages)[i].name = StringPrintf("cpu%d", i); - (*cpu_usages)[i].active = 0; - (*cpu_usages)[i].total = 0; - (*cpu_usages)[i].isOnline = false; - } - parseCpuUsagesFileAndAssignUsages(cpu_usages); - return true; -} - -bool ThermalHelper::readThermalSensor(std::string_view sensor_name, float *temp, - const bool force_sysfs) { - float temp_val = 0.0; - std::string file_reading; - std::string log_buf; - boot_clock::time_point now = boot_clock::now(); - - ATRACE_NAME(StringPrintf("ThermalHelper::readThermalSensor - %s", sensor_name.data()).c_str()); - if (!(sensor_info_map_.count(sensor_name.data()) && - sensor_status_map_.count(sensor_name.data()))) { - return false; - } - - const auto &sensor_info = sensor_info_map_.at(sensor_name.data()); - auto &sensor_status = sensor_status_map_.at(sensor_name.data()); - - // Check if thermal data need to be read from buffer - if (!force_sysfs && (sensor_status.thermal_cached.timestamp != boot_clock::time_point::min()) && - (std::chrono::duration_cast<std::chrono::milliseconds>( - now - sensor_status.thermal_cached.timestamp) < sensor_info.time_resolution) && - !isnan(sensor_status.thermal_cached.temp)) { - *temp = sensor_status.thermal_cached.temp; - LOG(VERBOSE) << "read " << sensor_name.data() << " from buffer, value:" << *temp; - return true; - } - - // Reading thermal sensor according to it's composition - if (sensor_info.virtual_sensor_info == nullptr) { - if (!thermal_sensors_.readThermalFile(sensor_name.data(), &file_reading)) { - return false; - } - - if (file_reading.empty()) { - LOG(ERROR) << "failed to read sensor: " << sensor_name; - return false; - } - *temp = std::stof(::android::base::Trim(file_reading)); - } else { - for (size_t i = 0; i < sensor_info.virtual_sensor_info->linked_sensors.size(); i++) { - float sensor_reading = 0.0; - if (!readThermalSensor(sensor_info.virtual_sensor_info->linked_sensors[i], - &sensor_reading, force_sysfs)) { - return false; - } - log_buf.append(StringPrintf("(%s: %0.2f)", - sensor_info.virtual_sensor_info->linked_sensors[i].c_str(), - sensor_reading)); - if (std::isnan(sensor_info.virtual_sensor_info->coefficients[i])) { - return false; - } - - float coefficient = sensor_info.virtual_sensor_info->coefficients[i]; - switch (sensor_info.virtual_sensor_info->formula) { - case FormulaOption::COUNT_THRESHOLD: - if ((coefficient < 0 && sensor_reading < -coefficient) || - (coefficient >= 0 && sensor_reading >= coefficient)) - temp_val += 1; - break; - case FormulaOption::WEIGHTED_AVG: - temp_val += sensor_reading * coefficient; - break; - case FormulaOption::MAXIMUM: - if (i == 0) - temp_val = std::numeric_limits<float>::lowest(); - if (sensor_reading * coefficient > temp_val) - temp_val = sensor_reading * coefficient; - break; - case FormulaOption::MINIMUM: - if (i == 0) - temp_val = std::numeric_limits<float>::max(); - if (sensor_reading * coefficient < temp_val) - temp_val = sensor_reading * coefficient; - break; - default: - break; - } - } - LOG(VERBOSE) << sensor_name.data() << "'s sub sensors:" << log_buf; - *temp = (temp_val + sensor_info.virtual_sensor_info->offset); - } - - { - std::unique_lock<std::shared_mutex> _lock(sensor_status_map_mutex_); - sensor_status.thermal_cached.temp = *temp; - sensor_status.thermal_cached.timestamp = now; - } - - return true; -} - -// This is called in the different thread context and will update sensor_status -// uevent_sensors is the set of sensors which trigger uevent from thermal core driver. -std::chrono::milliseconds ThermalHelper::thermalWatcherCallbackFunc( - const std::set<std::string> &uevent_sensors) { - std::vector<Temperature_2_0> temps; - std::vector<std::string> cooling_devices_to_update; - boot_clock::time_point now = boot_clock::now(); - auto min_sleep_ms = std::chrono::milliseconds::max(); - bool power_data_is_updated = false; - - ATRACE_CALL(); - for (auto &name_status_pair : sensor_status_map_) { - bool force_update = false; - bool force_sysfs = false; - Temperature_2_0 temp; - TemperatureThreshold threshold; - SensorStatus &sensor_status = name_status_pair.second; - const SensorInfo &sensor_info = sensor_info_map_.at(name_status_pair.first); - - // Only handle the sensors in allow list - if (!sensor_info.is_watch) { - continue; - } - - ATRACE_NAME(StringPrintf("ThermalHelper::thermalWatcherCallbackFunc - %s", - name_status_pair.first.data()) - .c_str()); - - std::chrono::milliseconds time_elapsed_ms = std::chrono::milliseconds::zero(); - auto sleep_ms = (sensor_status.severity != ThrottlingSeverity::NONE) - ? sensor_info.passive_delay - : sensor_info.polling_delay; - - if (sensor_info.virtual_sensor_info != nullptr && - !sensor_info.virtual_sensor_info->trigger_sensor.empty()) { - const auto trigger_sensor_status = - sensor_status_map_.at(sensor_info.virtual_sensor_info->trigger_sensor); - if (trigger_sensor_status.severity != ThrottlingSeverity::NONE) { - sleep_ms = sensor_info.passive_delay; - } - } - // Check if the sensor need to be updated - if (sensor_status.last_update_time == boot_clock::time_point::min()) { - force_update = true; - LOG(VERBOSE) << "Force update " << name_status_pair.first - << "'s temperature after booting"; - } else { - time_elapsed_ms = std::chrono::duration_cast<std::chrono::milliseconds>( - now - sensor_status.last_update_time); - if (time_elapsed_ms > sleep_ms) { - // Update the sensor because sleep timeout - force_update = true; - } else if (uevent_sensors.size() && - uevent_sensors.find((sensor_info.virtual_sensor_info != nullptr) - ? sensor_info.virtual_sensor_info->trigger_sensor - : name_status_pair.first) != - uevent_sensors.end()) { - // Force update the sensor from sysfs - force_update = true; - force_sysfs = true; - } - } - - LOG(VERBOSE) << "sensor " << name_status_pair.first - << ": time_elapsed=" << time_elapsed_ms.count() - << ", sleep_ms=" << sleep_ms.count() << ", force_update = " << force_update - << ", force_sysfs = " << force_sysfs; - - if (!force_update) { - auto timeout_remaining = sleep_ms - time_elapsed_ms; - if (min_sleep_ms > timeout_remaining) { - min_sleep_ms = timeout_remaining; - } - LOG(VERBOSE) << "sensor " << name_status_pair.first - << ": timeout_remaining=" << timeout_remaining.count(); - continue; - } - - std::pair<ThrottlingSeverity, ThrottlingSeverity> throtting_status; - if (!readTemperature(name_status_pair.first, &temp, &throtting_status, force_sysfs)) { - LOG(ERROR) << __func__ - << ": error reading temperature for sensor: " << name_status_pair.first; - continue; - } - if (!readTemperatureThreshold(name_status_pair.first, &threshold)) { - LOG(ERROR) << __func__ << ": error reading temperature threshold for sensor: " - << name_status_pair.first; - continue; - } - - { - // writer lock - std::unique_lock<std::shared_mutex> _lock(sensor_status_map_mutex_); - if (throtting_status.first != sensor_status.prev_hot_severity) { - sensor_status.prev_hot_severity = throtting_status.first; - } - if (throtting_status.second != sensor_status.prev_cold_severity) { - sensor_status.prev_cold_severity = throtting_status.second; - } - if (temp.throttlingStatus != sensor_status.severity) { - temps.push_back(temp); - sensor_status.severity = temp.throttlingStatus; - sleep_ms = (sensor_status.severity != ThrottlingSeverity::NONE) - ? sensor_info.passive_delay - : sensor_info.polling_delay; - } - } - - if (!power_data_is_updated) { - power_files_.refreshPowerStatus(); - power_data_is_updated = true; - } - - if (sensor_status.severity == ThrottlingSeverity::NONE) { - LOG(VERBOSE) << temp.name << ": " << temp.value; - thermal_throttling_.clearThrottlingData(name_status_pair.first, sensor_info); - } else { - LOG(INFO) << temp.name << ": " << temp.value; - // update thermal throttling request - thermal_throttling_.thermalThrottlingUpdate( - temp, sensor_info, sensor_status.severity, time_elapsed_ms, - power_files_.GetPowerStatusMap(), cooling_device_info_map_); - } - - thermal_throttling_.computeCoolingDevicesRequest(name_status_pair.first, sensor_info, - sensor_status.severity, - &cooling_devices_to_update); - if (min_sleep_ms > sleep_ms) { - min_sleep_ms = sleep_ms; - } - - LOG(VERBOSE) << "Sensor " << name_status_pair.first << ": sleep_ms=" << sleep_ms.count() - << ", min_sleep_ms voting result=" << min_sleep_ms.count(); - sensor_status.last_update_time = now; - } - - if (!cooling_devices_to_update.empty()) { - updateCoolingDevices(cooling_devices_to_update); - } - - if (!temps.empty()) { - for (const auto &t : temps) { - if (sensor_info_map_.at(t.name).send_cb && cb_) { - cb_(t); - } - - if (sensor_info_map_.at(t.name).send_powerhint && isAidlPowerHalExist()) { - sendPowerExtHint(t); - } - } - } - - return min_sleep_ms; -} - -bool ThermalHelper::connectToPowerHal() { - return power_hal_service_.connect(); -} - -void ThermalHelper::updateSupportedPowerHints() { - for (auto const &name_status_pair : sensor_info_map_) { - if (!(name_status_pair.second.send_powerhint)) { - continue; - } - ThrottlingSeverity current_severity = ThrottlingSeverity::NONE; - for (const auto &severity : hidl_enum_range<ThrottlingSeverity>()) { - if (severity == ThrottlingSeverity::NONE) { - supported_powerhint_map_[name_status_pair.first][ThrottlingSeverity::NONE] = - ThrottlingSeverity::NONE; - continue; - } - - bool isSupported = false; - ndk::ScopedAStatus isSupportedResult; - - if (power_hal_service_.isPowerHalExtConnected()) { - isSupported = power_hal_service_.isModeSupported(name_status_pair.first, severity); - } - if (isSupported) - current_severity = severity; - supported_powerhint_map_[name_status_pair.first][severity] = current_severity; - } - } -} - -void ThermalHelper::sendPowerExtHint(const Temperature_2_0 &t) { - ATRACE_CALL(); - std::lock_guard<std::shared_mutex> lock(sensor_status_map_mutex_); - ThrottlingSeverity prev_hint_severity; - prev_hint_severity = sensor_status_map_.at(t.name).prev_hint_severity; - ThrottlingSeverity current_hint_severity = supported_powerhint_map_[t.name][t.throttlingStatus]; - - if (prev_hint_severity == current_hint_severity) - return; - - if (prev_hint_severity != ThrottlingSeverity::NONE) { - power_hal_service_.setMode(t.name, prev_hint_severity, false); - } - - if (current_hint_severity != ThrottlingSeverity::NONE) { - power_hal_service_.setMode(t.name, current_hint_severity, true); - } - - sensor_status_map_[t.name].prev_hint_severity = current_hint_severity; -} -} // namespace implementation -} // namespace V2_0 -} // namespace thermal -} // namespace hardware -} // namespace android diff --git a/thermal/pid_1_0/thermal-helper.h b/thermal/pid_1_0/thermal-helper.h deleted file mode 100644 index 6b7cd9a9..00000000 --- a/thermal/pid_1_0/thermal-helper.h +++ /dev/null @@ -1,178 +0,0 @@ -/* - * Copyright (C) 2018 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. - */ - -#pragma once - -#include <array> -#include <chrono> -#include <mutex> -#include <shared_mutex> -#include <string> -#include <string_view> -#include <thread> -#include <unordered_map> -#include <vector> - -#include "utils/power_files.h" -#include "utils/powerhal_helper.h" -#include "utils/thermal_files.h" -#include "utils/thermal_info.h" -#include "utils/thermal_throttling.h" -#include "utils/thermal_watcher.h" - -namespace android { -namespace hardware { -namespace thermal { -namespace V2_0 { -namespace implementation { - -using ::android::hardware::hidl_vec; -using ::android::hardware::thermal::V1_0::CpuUsage; -using ::android::hardware::thermal::V2_0::CoolingType; -using ::android::hardware::thermal::V2_0::IThermal; -using CoolingDevice_1_0 = ::android::hardware::thermal::V1_0::CoolingDevice; -using CoolingDevice_2_0 = ::android::hardware::thermal::V2_0::CoolingDevice; -using Temperature_1_0 = ::android::hardware::thermal::V1_0::Temperature; -using Temperature_2_0 = ::android::hardware::thermal::V2_0::Temperature; -using TemperatureType_1_0 = ::android::hardware::thermal::V1_0::TemperatureType; -using TemperatureType_2_0 = ::android::hardware::thermal::V2_0::TemperatureType; -using ::android::hardware::thermal::V2_0::TemperatureThreshold; -using ::android::hardware::thermal::V2_0::ThrottlingSeverity; - -using NotificationCallback = std::function<void(const Temperature_2_0 &t)>; -using NotificationTime = std::chrono::time_point<std::chrono::steady_clock>; - -// Get thermal_zone type -bool getThermalZoneTypeById(int tz_id, std::string *); - -struct ThermalSample { - float temp; - boot_clock::time_point timestamp; -}; - -struct SensorStatus { - ThrottlingSeverity severity; - ThrottlingSeverity prev_hot_severity; - ThrottlingSeverity prev_cold_severity; - ThrottlingSeverity prev_hint_severity; - boot_clock::time_point last_update_time; - ThermalSample thermal_cached; -}; - -class ThermalHelper { - public: - explicit ThermalHelper(const NotificationCallback &cb); - ~ThermalHelper() = default; - - bool fillTemperatures(hidl_vec<Temperature_1_0> *temperatures); - bool fillCurrentTemperatures(bool filterType, bool filterCallback, TemperatureType_2_0 type, - hidl_vec<Temperature_2_0> *temperatures); - bool fillTemperatureThresholds(bool filterType, TemperatureType_2_0 type, - hidl_vec<TemperatureThreshold> *thresholds) const; - bool fillCurrentCoolingDevices(bool filterType, CoolingType type, - hidl_vec<CoolingDevice_2_0> *coolingdevices) const; - bool fillCpuUsages(hidl_vec<CpuUsage> *cpu_usages) const; - - // Dissallow copy and assign. - ThermalHelper(const ThermalHelper &) = delete; - void operator=(const ThermalHelper &) = delete; - - bool isInitializedOk() const { return is_initialized_; } - - // Read the temperature of a single sensor. - bool readTemperature(std::string_view sensor_name, Temperature_1_0 *out); - bool readTemperature( - std::string_view sensor_name, Temperature_2_0 *out, - std::pair<ThrottlingSeverity, ThrottlingSeverity> *throtting_status = nullptr, - const bool force_sysfs = false); - bool readTemperatureThreshold(std::string_view sensor_name, TemperatureThreshold *out) const; - // Read the value of a single cooling device. - bool readCoolingDevice(std::string_view cooling_device, CoolingDevice_2_0 *out) const; - // Get SensorInfo Map - const std::unordered_map<std::string, SensorInfo> &GetSensorInfoMap() const { - return sensor_info_map_; - } - // Get CdevInfo Map - const std::unordered_map<std::string, CdevInfo> &GetCdevInfoMap() const { - return cooling_device_info_map_; - } - // Get SensorStatus Map - const std::unordered_map<std::string, SensorStatus> &GetSensorStatusMap() const { - std::shared_lock<std::shared_mutex> _lock(sensor_status_map_mutex_); - return sensor_status_map_; - } - // Get ThermalThrottling Map - const std::unordered_map<std::string, ThermalThrottlingStatus> &GetThermalThrottlingStatusMap() - const { - return thermal_throttling_.GetThermalThrottlingStatusMap(); - } - // Get PowerRailInfo Map - const std::unordered_map<std::string, PowerRailInfo> &GetPowerRailInfoMap() const { - return power_files_.GetPowerRailInfoMap(); - } - - // Get PowerStatus Map - const std::unordered_map<std::string, PowerStatus> &GetPowerStatusMap() const { - return power_files_.GetPowerStatusMap(); - } - void sendPowerExtHint(const Temperature_2_0 &t); - bool isAidlPowerHalExist() { return power_hal_service_.isAidlPowerHalExist(); } - bool isPowerHalConnected() { return power_hal_service_.isPowerHalConnected(); } - bool isPowerHalExtConnected() { return power_hal_service_.isPowerHalExtConnected(); } - - private: - bool initializeSensorMap(const std::unordered_map<std::string, std::string> &path_map); - bool initializeCoolingDevices(const std::unordered_map<std::string, std::string> &path_map); - void setMinTimeout(SensorInfo *sensor_info); - void initializeTrip(const std::unordered_map<std::string, std::string> &path_map, - std::set<std::string> *monitored_sensors, bool thermal_genl_enabled); - - // For thermal_watcher_'s polling thread, return the sleep interval - std::chrono::milliseconds thermalWatcherCallbackFunc( - const std::set<std::string> &uevent_sensors); - // Return hot and cold severity status as std::pair - std::pair<ThrottlingSeverity, ThrottlingSeverity> getSeverityFromThresholds( - const ThrottlingArray &hot_thresholds, const ThrottlingArray &cold_thresholds, - const ThrottlingArray &hot_hysteresis, const ThrottlingArray &cold_hysteresis, - ThrottlingSeverity prev_hot_severity, ThrottlingSeverity prev_cold_severity, - float value) const; - // Read temperature data according to thermal sensor's info - bool readThermalSensor(std::string_view sensor_name, float *temp, const bool force_sysfs); - bool connectToPowerHal(); - void updateSupportedPowerHints(); - void updateCoolingDevices(const std::vector<std::string> &cooling_devices_to_update); - sp<ThermalWatcher> thermal_watcher_; - PowerFiles power_files_; - ThermalFiles thermal_sensors_; - ThermalFiles cooling_devices_; - ThermalThrottling thermal_throttling_; - bool is_initialized_; - const NotificationCallback cb_; - std::unordered_map<std::string, CdevInfo> cooling_device_info_map_; - std::unordered_map<std::string, SensorInfo> sensor_info_map_; - std::unordered_map<std::string, std::map<ThrottlingSeverity, ThrottlingSeverity>> - supported_powerhint_map_; - PowerHalService power_hal_service_; - - mutable std::shared_mutex sensor_status_map_mutex_; - std::unordered_map<std::string, SensorStatus> sensor_status_map_; -}; - -} // namespace implementation -} // namespace V2_0 -} // namespace thermal -} // namespace hardware -} // namespace android diff --git a/thermal/pid_1_0/utils/power_files.cpp b/thermal/pid_1_0/utils/power_files.cpp deleted file mode 100644 index 3561e847..00000000 --- a/thermal/pid_1_0/utils/power_files.cpp +++ /dev/null @@ -1,342 +0,0 @@ - -/* - * 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 ATRACE_TAG (ATRACE_TAG_THERMAL | ATRACE_TAG_HAL) - -#include "power_files.h" - -#include <android-base/file.h> -#include <android-base/logging.h> -#include <android-base/stringprintf.h> -#include <android-base/strings.h> -#include <dirent.h> -#include <utils/Trace.h> - -namespace android { -namespace hardware { -namespace thermal { -namespace V2_0 { -namespace implementation { - -constexpr std::string_view kDeviceType("iio:device"); -constexpr std::string_view kIioRootDir("/sys/bus/iio/devices"); -constexpr std::string_view kEnergyValueNode("energy_value"); - -using android::base::ReadFileToString; -using android::base::StringPrintf; - -bool PowerFiles::registerPowerRailsToWatch(std::string_view config_path) { - if (!ParsePowerRailInfo(config_path, &power_rail_info_map_)) { - LOG(ERROR) << "Failed to parse power rail info config"; - return false; - } - - if (!power_rail_info_map_.size()) { - LOG(INFO) << " No power rail info config found"; - return true; - } - - if (!findEnergySourceToWatch()) { - LOG(ERROR) << "Cannot find energy source"; - return false; - } - - if (!energy_info_map_.size() && !updateEnergyValues()) { - LOG(ERROR) << "Faield to update energy info"; - return false; - } - - for (const auto &power_rail_info_pair : power_rail_info_map_) { - std::vector<std::queue<PowerSample>> power_history; - if (!power_rail_info_pair.second.power_sample_count || - power_rail_info_pair.second.power_sample_delay == std::chrono::milliseconds::max()) { - continue; - } - - PowerSample power_sample = { - .energy_counter = 0, - .duration = 0, - }; - - if (power_rail_info_pair.second.virtual_power_rail_info != nullptr && - power_rail_info_pair.second.virtual_power_rail_info->linked_power_rails.size()) { - for (size_t i = 0; - i < power_rail_info_pair.second.virtual_power_rail_info->linked_power_rails.size(); - ++i) { - if (!energy_info_map_.count(power_rail_info_pair.second.virtual_power_rail_info - ->linked_power_rails[i])) { - LOG(ERROR) << " Could not find energy source " - << power_rail_info_pair.second.virtual_power_rail_info - ->linked_power_rails[i]; - return false; - } - power_history.emplace_back(std::queue<PowerSample>()); - for (int j = 0; j < power_rail_info_pair.second.power_sample_count; j++) { - power_history[i].emplace(power_sample); - } - } - } else { - if (energy_info_map_.count(power_rail_info_pair.first)) { - power_history.emplace_back(std::queue<PowerSample>()); - for (int j = 0; j < power_rail_info_pair.second.power_sample_count; j++) { - power_history[0].emplace(power_sample); - } - } else { - LOG(ERROR) << "Could not find energy source " << power_rail_info_pair.first; - return false; - } - } - - if (power_history.size()) { - power_status_map_[power_rail_info_pair.first] = { - .power_history = power_history, - .last_update_time = boot_clock::time_point::min(), - .last_updated_avg_power = NAN, - }; - } else { - LOG(ERROR) << "power history size is zero"; - return false; - } - LOG(INFO) << "Successfully to register power rail " << power_rail_info_pair.first; - } - return true; -} - -bool PowerFiles::findEnergySourceToWatch(void) { - std::string devicePath; - - if (energy_path_set_.size()) { - return true; - } - - std::unique_ptr<DIR, decltype(&closedir)> dir(opendir(kIioRootDir.data()), closedir); - if (!dir) { - PLOG(ERROR) << "Error opening directory" << kIioRootDir; - return false; - } - - // Find any iio:devices that support energy_value - while (struct dirent *ent = readdir(dir.get())) { - std::string devTypeDir = ent->d_name; - if (devTypeDir.find(kDeviceType) != std::string::npos) { - devicePath = StringPrintf("%s/%s", kIioRootDir.data(), devTypeDir.data()); - std::string deviceEnergyContent; - - if (!ReadFileToString(StringPrintf("%s/%s", devicePath.data(), kEnergyValueNode.data()), - &deviceEnergyContent)) { - } else if (deviceEnergyContent.size()) { - energy_path_set_.emplace( - StringPrintf("%s/%s", devicePath.data(), kEnergyValueNode.data())); - } - } - } - - if (!energy_path_set_.size()) { - return false; - } - - return true; -} - -bool PowerFiles::updateEnergyValues(void) { - std::string deviceEnergyContent; - std::string deviceEnergyContents; - std::string line; - - ATRACE_CALL(); - for (const auto &path : energy_path_set_) { - if (!android::base::ReadFileToString(path, &deviceEnergyContent)) { - LOG(ERROR) << "Failed to read energy content from " << path; - return false; - } else { - deviceEnergyContents.append(deviceEnergyContent); - } - } - - std::istringstream energyData(deviceEnergyContents); - - while (std::getline(energyData, line)) { - /* Read rail energy */ - uint64_t energy_counter = 0; - uint64_t duration = 0; - - /* Format example: CH3(T=358356)[S2M_VDD_CPUCL2], 761330 */ - auto start_pos = line.find("T="); - auto end_pos = line.find(')'); - if (start_pos != std::string::npos) { - duration = - strtoul(line.substr(start_pos + 2, end_pos - start_pos - 2).c_str(), NULL, 10); - } else { - continue; - } - - start_pos = line.find(")["); - end_pos = line.find(']'); - std::string railName; - if (start_pos != std::string::npos) { - railName = line.substr(start_pos + 2, end_pos - start_pos - 2); - } else { - continue; - } - - start_pos = line.find("],"); - if (start_pos != std::string::npos) { - energy_counter = strtoul(line.substr(start_pos + 2).c_str(), NULL, 10); - } else { - continue; - } - - energy_info_map_[railName] = { - .energy_counter = energy_counter, - .duration = duration, - }; - } - - return true; -} - -float PowerFiles::updateAveragePower(std::string_view power_rail, - std::queue<PowerSample> *power_history) { - float avg_power = NAN; - - if (!energy_info_map_.count(power_rail.data())) { - LOG(ERROR) << " Could not find power rail " << power_rail.data(); - return avg_power; - } - const auto last_sample = power_history->front(); - const auto curr_sample = energy_info_map_.at(power_rail.data()); - const auto duration = curr_sample.duration - last_sample.duration; - const auto deltaEnergy = curr_sample.energy_counter - last_sample.energy_counter; - - if (!last_sample.duration) { - LOG(VERBOSE) << "Power rail " << power_rail.data() - << ": all power samples have not been collected yet"; - } else if (duration <= 0 || deltaEnergy < 0) { - LOG(ERROR) << "Power rail " << power_rail.data() << " is invalid: duration = " << duration - << ", deltaEnergy = " << deltaEnergy; - - return avg_power; - } else { - avg_power = static_cast<float>(deltaEnergy) / static_cast<float>(duration); - LOG(VERBOSE) << "Power rail " << power_rail.data() << ", avg power = " << avg_power - << ", duration = " << duration << ", deltaEnergy = " << deltaEnergy; - } - - power_history->pop(); - power_history->push(curr_sample); - - return avg_power; -} - -float PowerFiles::updatePowerRail(std::string_view power_rail) { - float avg_power = NAN; - - if (!power_rail_info_map_.count(power_rail.data())) { - return avg_power; - } - - if (!power_status_map_.count(power_rail.data())) { - return avg_power; - } - - const auto &power_rail_info = power_rail_info_map_.at(power_rail.data()); - auto &power_status = power_status_map_.at(power_rail.data()); - - boot_clock::time_point now = boot_clock::now(); - auto time_elapsed_ms = std::chrono::duration_cast<std::chrono::milliseconds>( - now - power_status.last_update_time); - - if (power_status.last_update_time != boot_clock::time_point::min() && - time_elapsed_ms < power_rail_info.power_sample_delay) { - return power_status.last_updated_avg_power; - } - - if (!energy_info_map_.size() && !updateEnergyValues()) { - LOG(ERROR) << "Failed to update energy values"; - return avg_power; - } - - if (power_rail_info.virtual_power_rail_info == nullptr) { - avg_power = updateAveragePower(power_rail, &power_status.power_history[0]); - } else { - const auto offset = power_rail_info.virtual_power_rail_info->offset; - float avg_power_val = 0.0; - for (size_t i = 0; i < power_rail_info.virtual_power_rail_info->linked_power_rails.size(); - i++) { - float coefficient = power_rail_info.virtual_power_rail_info->coefficients[i]; - float avg_power_number = updateAveragePower( - power_rail_info.virtual_power_rail_info->linked_power_rails[i], - &power_status.power_history[i]); - - switch (power_rail_info.virtual_power_rail_info->formula) { - case FormulaOption::COUNT_THRESHOLD: - if ((coefficient < 0 && avg_power_number < -coefficient) || - (coefficient >= 0 && avg_power_number >= coefficient)) - avg_power_val += 1; - break; - case FormulaOption::WEIGHTED_AVG: - avg_power_val += avg_power_number * coefficient; - break; - case FormulaOption::MAXIMUM: - if (i == 0) - avg_power_val = std::numeric_limits<float>::lowest(); - if (avg_power_number * coefficient > avg_power_val) - avg_power_val = avg_power_number * coefficient; - break; - case FormulaOption::MINIMUM: - if (i == 0) - avg_power_val = std::numeric_limits<float>::max(); - if (avg_power_number * coefficient < avg_power_val) - avg_power_val = avg_power_number * coefficient; - break; - default: - break; - } - } - if (avg_power_val >= 0) { - avg_power_val = avg_power_val + offset; - } - - avg_power = avg_power_val; - } - - if (avg_power < 0) { - avg_power = NAN; - } - - power_status.last_updated_avg_power = avg_power; - power_status.last_update_time = now; - return avg_power; -} - -bool PowerFiles::refreshPowerStatus(void) { - if (!updateEnergyValues()) { - LOG(ERROR) << "Failed to update energy values"; - return false; - } - - for (const auto &power_status_pair : power_status_map_) { - updatePowerRail(power_status_pair.first); - } - return true; -} - -} // namespace implementation -} // namespace V2_0 -} // namespace thermal -} // namespace hardware -} // namespace android diff --git a/thermal/pid_1_0/utils/power_files.h b/thermal/pid_1_0/utils/power_files.h deleted file mode 100644 index 65c67584..00000000 --- a/thermal/pid_1_0/utils/power_files.h +++ /dev/null @@ -1,95 +0,0 @@ -/* - * 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. - */ - -#pragma once - -#include <android-base/chrono_utils.h> - -#include <chrono> -#include <queue> -#include <shared_mutex> -#include <string> -#include <unordered_map> -#include <unordered_set> - -#include "thermal_info.h" - -namespace android { -namespace hardware { -namespace thermal { -namespace V2_0 { -namespace implementation { - -using android::base::boot_clock; - -struct PowerSample { - uint64_t energy_counter; - uint64_t duration; -}; - -struct PowerStatus { - boot_clock::time_point last_update_time; - // A vector to record the queues of power sample history. - std::vector<std::queue<PowerSample>> power_history; - float last_updated_avg_power; -}; - -// A helper class for monitoring power rails. -class PowerFiles { - public: - PowerFiles() = default; - ~PowerFiles() = default; - // Disallow copy and assign. - PowerFiles(const PowerFiles &) = delete; - void operator=(const PowerFiles &) = delete; - bool registerPowerRailsToWatch(std::string_view config_path); - // Update the power data from ODPM sysfs - bool refreshPowerStatus(void); - // Get power status map - const std::unordered_map<std::string, PowerStatus> &GetPowerStatusMap() const { - std::shared_lock<std::shared_mutex> _lock(power_status_map_mutex_); - return power_status_map_; - } - // Get power rail info map - const std::unordered_map<std::string, PowerRailInfo> &GetPowerRailInfoMap() const { - return power_rail_info_map_; - } - - private: - // Update energy value to energy_info_map_, return false if the value is failed to update. - bool updateEnergyValues(void); - // Compute the average power for physical power rail. - float updateAveragePower(std::string_view power_rail, std::queue<PowerSample> *power_history); - // Update the power data for the target power rail. - float updatePowerRail(std::string_view power_rail); - // Find the energy source path, return false if no energy source found. - bool findEnergySourceToWatch(void); - // The map to record the energy counter for each power rail. - std::unordered_map<std::string, PowerSample> energy_info_map_; - // The map to record the power data for each thermal sensor. - std::unordered_map<std::string, PowerStatus> power_status_map_; - mutable std::shared_mutex power_status_map_mutex_; - // The map to record the power rail information from thermal config - std::unordered_map<std::string, PowerRailInfo> power_rail_info_map_; - // The set to store the energy source paths - std::unordered_set<std::string> energy_path_set_; -}; - -} // namespace implementation -} // namespace V2_0 -} // namespace thermal -} // namespace hardware -} // namespace android diff --git a/thermal/pid_1_0/utils/powerhal_helper.cpp b/thermal/pid_1_0/utils/powerhal_helper.cpp deleted file mode 100644 index 515fa2d9..00000000 --- a/thermal/pid_1_0/utils/powerhal_helper.cpp +++ /dev/null @@ -1,134 +0,0 @@ -/* - * Copyright (C) 2022 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. - */ - -#include "powerhal_helper.h" - -#include <android-base/file.h> -#include <android-base/logging.h> -#include <android-base/properties.h> -#include <android-base/stringprintf.h> -#include <android-base/strings.h> -#include <android/binder_manager.h> -#include <hidl/HidlTransportSupport.h> - -#include <iterator> -#include <set> -#include <sstream> -#include <thread> -#include <vector> - -#include "thermal_info.h" -#include "thermal_throttling.h" - -namespace android { -namespace hardware { -namespace thermal { -namespace V2_0 { -namespace implementation { - -using android::base::StringPrintf; - -PowerHalService::PowerHalService() - : power_hal_aidl_exist_(true), power_hal_aidl_(nullptr), power_hal_ext_aidl_(nullptr) { - connect(); -} - -bool PowerHalService::connect() { - std::lock_guard<std::mutex> lock(lock_); - if (!power_hal_aidl_exist_) - return false; - - if (power_hal_aidl_ != nullptr) - return true; - - const std::string kInstance = std::string(IPower::descriptor) + "/default"; - ndk::SpAIBinder power_binder = ndk::SpAIBinder(AServiceManager_getService(kInstance.c_str())); - ndk::SpAIBinder ext_power_binder; - - if (power_binder.get() == nullptr) { - LOG(ERROR) << "Cannot get Power Hal Binder"; - power_hal_aidl_exist_ = false; - return false; - } - - power_hal_aidl_ = IPower::fromBinder(power_binder); - - if (power_hal_aidl_ == nullptr) { - power_hal_aidl_exist_ = false; - LOG(ERROR) << "Cannot get Power Hal AIDL" << kInstance.c_str(); - return false; - } - - if (STATUS_OK != AIBinder_getExtension(power_binder.get(), ext_power_binder.getR()) || - ext_power_binder.get() == nullptr) { - LOG(ERROR) << "Cannot get Power Hal Extension Binder"; - power_hal_aidl_exist_ = false; - return false; - } - - power_hal_ext_aidl_ = IPowerExt::fromBinder(ext_power_binder); - if (power_hal_ext_aidl_ == nullptr) { - LOG(ERROR) << "Cannot get Power Hal Extension AIDL"; - power_hal_aidl_exist_ = false; - } - - return true; -} - -bool PowerHalService::isModeSupported(const std::string &type, const ThrottlingSeverity &t) { - bool isSupported = false; - if (!isPowerHalConnected()) { - return false; - } - std::string power_hint = StringPrintf("THERMAL_%s_%s", type.c_str(), toString(t).c_str()); - lock_.lock(); - if (!power_hal_ext_aidl_->isModeSupported(power_hint, &isSupported).isOk()) { - LOG(ERROR) << "Fail to check supported mode, Hint: " << power_hint; - power_hal_aidl_exist_ = false; - power_hal_ext_aidl_ = nullptr; - power_hal_aidl_ = nullptr; - lock_.unlock(); - return false; - } - lock_.unlock(); - return isSupported; -} - -void PowerHalService::setMode(const std::string &type, const ThrottlingSeverity &t, - const bool &enable) { - if (!isPowerHalConnected()) { - return; - } - - std::string power_hint = StringPrintf("THERMAL_%s_%s", type.c_str(), toString(t).c_str()); - LOG(INFO) << "Send Hint " << power_hint << " Enable: " << std::boolalpha << enable; - lock_.lock(); - if (!power_hal_ext_aidl_->setMode(power_hint, enable).isOk()) { - LOG(ERROR) << "Fail to set mode, Hint: " << power_hint; - power_hal_aidl_exist_ = false; - power_hal_ext_aidl_ = nullptr; - power_hal_aidl_ = nullptr; - lock_.unlock(); - return; - } - lock_.unlock(); -} - -} // namespace implementation -} // namespace V2_0 -} // namespace thermal -} // namespace hardware -} // namespace android diff --git a/thermal/pid_1_0/utils/powerhal_helper.h b/thermal/pid_1_0/utils/powerhal_helper.h deleted file mode 100644 index 761e315c..00000000 --- a/thermal/pid_1_0/utils/powerhal_helper.h +++ /dev/null @@ -1,67 +0,0 @@ -/* - * Copyright (C) 2022 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. - */ - -#pragma once - -#include <aidl/android/hardware/power/IPower.h> -#include <aidl/google/hardware/power/extension/pixel/IPowerExt.h> -#include <android/hardware/thermal/2.0/IThermal.h> - -#include <queue> -#include <shared_mutex> -#include <string> -#include <unordered_map> -#include <unordered_set> - -namespace android { -namespace hardware { -namespace thermal { -namespace V2_0 { -namespace implementation { - -using ::aidl::android::hardware::power::IPower; -using ::aidl::google::hardware::power::extension::pixel::IPowerExt; - -using ::android::hardware::hidl_vec; -using ::android::hardware::thermal::V2_0::IThermal; -using Temperature_2_0 = ::android::hardware::thermal::V2_0::Temperature; -using ::android::hardware::thermal::V2_0::TemperatureThreshold; -using ::android::hardware::thermal::V2_0::ThrottlingSeverity; -using CdevRequestStatus = std::unordered_map<std::string, int>; - -class PowerHalService { - public: - PowerHalService(); - ~PowerHalService() = default; - bool connect(); - bool isAidlPowerHalExist() { return power_hal_aidl_exist_; } - bool isModeSupported(const std::string &type, const ThrottlingSeverity &t); - bool isPowerHalConnected() { return power_hal_aidl_ != nullptr; } - bool isPowerHalExtConnected() { return power_hal_ext_aidl_ != nullptr; } - void setMode(const std::string &type, const ThrottlingSeverity &t, const bool &enable); - - private: - bool power_hal_aidl_exist_; - std::shared_ptr<IPower> power_hal_aidl_; - std::shared_ptr<IPowerExt> power_hal_ext_aidl_; - std::mutex lock_; -}; - -} // namespace implementation -} // namespace V2_0 -} // namespace thermal -} // namespace hardware -} // namespace android diff --git a/thermal/pid_1_0/utils/thermal_files.cpp b/thermal/pid_1_0/utils/thermal_files.cpp deleted file mode 100644 index ff10d8b6..00000000 --- a/thermal/pid_1_0/utils/thermal_files.cpp +++ /dev/null @@ -1,88 +0,0 @@ -/* - * 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 ATRACE_TAG (ATRACE_TAG_THERMAL | ATRACE_TAG_HAL) - -#include "thermal_files.h" - -#include <android-base/file.h> -#include <android-base/logging.h> -#include <android-base/stringprintf.h> -#include <android-base/strings.h> -#include <utils/Trace.h> - -#include <algorithm> -#include <string_view> - -namespace android { -namespace hardware { -namespace thermal { -namespace V2_0 { -namespace implementation { - -using android::base::StringPrintf; - -std::string ThermalFiles::getThermalFilePath(std::string_view thermal_name) const { - auto sensor_itr = thermal_name_to_path_map_.find(thermal_name.data()); - if (sensor_itr == thermal_name_to_path_map_.end()) { - return ""; - } - return sensor_itr->second; -} - -bool ThermalFiles::addThermalFile(std::string_view thermal_name, std::string_view path) { - return thermal_name_to_path_map_.emplace(thermal_name, path).second; -} - -bool ThermalFiles::readThermalFile(std::string_view thermal_name, std::string *data) const { - std::string sensor_reading; - std::string file_path = getThermalFilePath(std::string_view(thermal_name)); - *data = ""; - - ATRACE_NAME(StringPrintf("ThermalFiles::readThermalFile - %s", thermal_name.data()).c_str()); - if (file_path.empty()) { - PLOG(WARNING) << "Failed to find " << thermal_name << "'s path"; - return false; - } - - if (!::android::base::ReadFileToString(file_path, &sensor_reading)) { - PLOG(WARNING) << "Failed to read sensor: " << thermal_name; - return false; - } - - // Strip the newline. - *data = ::android::base::Trim(sensor_reading); - return true; -} - -bool ThermalFiles::writeCdevFile(std::string_view cdev_name, std::string_view data) { - std::string file_path = - getThermalFilePath(android::base::StringPrintf("%s_%s", cdev_name.data(), "w")); - - ATRACE_NAME(StringPrintf("ThermalFiles::writeCdevFile - %s", cdev_name.data()).c_str()); - if (!android::base::WriteStringToFile(data.data(), file_path)) { - PLOG(WARNING) << "Failed to write cdev: " << cdev_name << " to " << data.data(); - return false; - } - - return true; -} - -} // namespace implementation -} // namespace V2_0 -} // namespace thermal -} // namespace hardware -} // namespace android diff --git a/thermal/pid_1_0/utils/thermal_files.h b/thermal/pid_1_0/utils/thermal_files.h deleted file mode 100644 index 59afba64..00000000 --- a/thermal/pid_1_0/utils/thermal_files.h +++ /dev/null @@ -1,53 +0,0 @@ -/* - * 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. - */ - -#pragma once - -#include <string> -#include <unordered_map> - -namespace android { -namespace hardware { -namespace thermal { -namespace V2_0 { -namespace implementation { - -class ThermalFiles { - public: - ThermalFiles() = default; - ~ThermalFiles() = default; - ThermalFiles(const ThermalFiles &) = delete; - void operator=(const ThermalFiles &) = delete; - - std::string getThermalFilePath(std::string_view thermal_name) const; - // Returns true if add was successful, false otherwise. - bool addThermalFile(std::string_view thermal_name, std::string_view path); - // If thermal_name is not found in the thermal names to path map, this will set - // data to empty and return false. If the thermal_name is found and its content - // is read, this function will fill in data accordingly then return true. - bool readThermalFile(std::string_view thermal_name, std::string *data) const; - bool writeCdevFile(std::string_view thermal_name, std::string_view data); - size_t getNumThermalFiles() const { return thermal_name_to_path_map_.size(); } - - private: - std::unordered_map<std::string, std::string> thermal_name_to_path_map_; -}; - -} // namespace implementation -} // namespace V2_0 -} // namespace thermal -} // namespace hardware -} // namespace android diff --git a/thermal/pid_1_0/utils/thermal_info.cpp b/thermal/pid_1_0/utils/thermal_info.cpp deleted file mode 100644 index 7ed63c32..00000000 --- a/thermal/pid_1_0/utils/thermal_info.cpp +++ /dev/null @@ -1,1021 +0,0 @@ -/* - * Copyright (C) 2018 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. - */ -#include "thermal_info.h" - -#include <android-base/file.h> -#include <android-base/logging.h> -#include <android-base/properties.h> -#include <android-base/strings.h> -#include <json/reader.h> -#include <json/value.h> - -#include <cmath> -#include <unordered_set> - -namespace android { -namespace hardware { -namespace thermal { -namespace V2_0 { -namespace implementation { - -constexpr std::string_view kPowerLinkDisabledProperty("vendor.disable.thermal.powerlink"); - -using ::android::hardware::hidl_enum_range; -using ::android::hardware::thermal::V2_0::toString; -using TemperatureType_2_0 = ::android::hardware::thermal::V2_0::TemperatureType; - -namespace { - -template <typename T> -// Return false when failed parsing -bool getTypeFromString(std::string_view str, T *out) { - auto types = hidl_enum_range<T>(); - for (const auto &type : types) { - if (toString(type) == str) { - *out = type; - return true; - } - } - return false; -} - -float getFloatFromValue(const Json::Value &value) { - if (value.isString()) { - return std::stof(value.asString()); - } else { - return value.asFloat(); - } -} - -int getIntFromValue(const Json::Value &value) { - if (value.isString()) { - return (value.asString() == "max") ? std::numeric_limits<int>::max() - : std::stoul(value.asString()); - } else { - return value.asInt(); - } -} - -bool getIntFromJsonValues(const Json::Value &values, CdevArray *out, bool inc_check, - bool dec_check) { - CdevArray ret; - - if (inc_check && dec_check) { - LOG(ERROR) << "Cannot enable inc_check and dec_check at the same time"; - return false; - } - - if (values.size() != kThrottlingSeverityCount) { - LOG(ERROR) << "Values size is invalid"; - return false; - } else { - int last; - for (Json::Value::ArrayIndex i = 0; i < kThrottlingSeverityCount; ++i) { - ret[i] = getIntFromValue(values[i]); - if (inc_check && ret[i] < last) { - LOG(FATAL) << "Invalid array[" << i << "]" << ret[i] << " min=" << last; - return false; - } - if (dec_check && ret[i] > last) { - LOG(FATAL) << "Invalid array[" << i << "]" << ret[i] << " max=" << last; - return false; - } - last = ret[i]; - LOG(INFO) << "[" << i << "]: " << ret[i]; - } - } - - *out = ret; - return true; -} - -bool getFloatFromJsonValues(const Json::Value &values, ThrottlingArray *out, bool inc_check, - bool dec_check) { - ThrottlingArray ret; - - if (inc_check && dec_check) { - LOG(ERROR) << "Cannot enable inc_check and dec_check at the same time"; - return false; - } - - if (values.size() != kThrottlingSeverityCount) { - LOG(ERROR) << "Values size is invalid"; - return false; - } else { - float last = std::nanf(""); - for (Json::Value::ArrayIndex i = 0; i < kThrottlingSeverityCount; ++i) { - ret[i] = getFloatFromValue(values[i]); - if (inc_check && !std::isnan(last) && !std::isnan(ret[i]) && ret[i] < last) { - LOG(FATAL) << "Invalid array[" << i << "]" << ret[i] << " min=" << last; - return false; - } - if (dec_check && !std::isnan(last) && !std::isnan(ret[i]) && ret[i] > last) { - LOG(FATAL) << "Invalid array[" << i << "]" << ret[i] << " max=" << last; - return false; - } - last = std::isnan(ret[i]) ? last : ret[i]; - LOG(INFO) << "[" << i << "]: " << ret[i]; - } - } - - *out = ret; - return true; -} -} // namespace - -bool ParseSensorInfo(std::string_view config_path, - std::unordered_map<std::string, SensorInfo> *sensors_parsed) { - std::string json_doc; - if (!android::base::ReadFileToString(config_path.data(), &json_doc)) { - LOG(ERROR) << "Failed to read JSON config from " << config_path; - return false; - } - Json::Value root; - Json::CharReaderBuilder builder; - std::unique_ptr<Json::CharReader> reader(builder.newCharReader()); - std::string errorMessage; - - if (!reader->parse(&*json_doc.begin(), &*json_doc.end(), &root, &errorMessage)) { - LOG(ERROR) << "Failed to parse JSON config: " << errorMessage; - return false; - } - - Json::Value sensors = root["Sensors"]; - std::size_t total_parsed = 0; - std::unordered_set<std::string> sensors_name_parsed; - - for (Json::Value::ArrayIndex i = 0; i < sensors.size(); ++i) { - const std::string &name = sensors[i]["Name"].asString(); - LOG(INFO) << "Sensor[" << i << "]'s Name: " << name; - if (name.empty()) { - LOG(ERROR) << "Failed to read " - << "Sensor[" << i << "]'s Name"; - sensors_parsed->clear(); - return false; - } - - auto result = sensors_name_parsed.insert(name); - if (!result.second) { - LOG(ERROR) << "Duplicate Sensor[" << i << "]'s Name"; - sensors_parsed->clear(); - return false; - } - - std::string sensor_type_str = sensors[i]["Type"].asString(); - LOG(INFO) << "Sensor[" << name << "]'s Type: " << sensor_type_str; - TemperatureType_2_0 sensor_type; - - if (!getTypeFromString(sensor_type_str, &sensor_type)) { - LOG(ERROR) << "Invalid " - << "Sensor[" << name << "]'s Type: " << sensor_type_str; - sensors_parsed->clear(); - return false; - } - - bool send_cb = false; - if (sensors[i]["Monitor"].empty() || !sensors[i]["Monitor"].isBool()) { - LOG(INFO) << "Failed to read Sensor[" << name << "]'s Monitor, set to 'false'"; - } else if (sensors[i]["Monitor"].asBool()) { - send_cb = true; - } - LOG(INFO) << "Sensor[" << name << "]'s SendCallback: " << std::boolalpha << send_cb - << std::noboolalpha; - - bool send_powerhint = false; - if (sensors[i]["SendPowerHint"].empty() || !sensors[i]["SendPowerHint"].isBool()) { - LOG(INFO) << "Failed to read Sensor[" << name << "]'s SendPowerHint, set to 'false'"; - } else if (sensors[i]["SendPowerHint"].asBool()) { - send_powerhint = true; - } - LOG(INFO) << "Sensor[" << name << "]'s SendPowerHint: " << std::boolalpha << send_powerhint - << std::noboolalpha; - - bool is_hidden = false; - if (sensors[i]["Hidden"].empty() || !sensors[i]["Hidden"].isBool()) { - LOG(INFO) << "Failed to read Sensor[" << name << "]'s Hidden, set to 'false'"; - } else if (sensors[i]["Hidden"].asBool()) { - is_hidden = true; - } - LOG(INFO) << "Sensor[" << name << "]'s Hidden: " << std::boolalpha << is_hidden - << std::noboolalpha; - - std::array<float, kThrottlingSeverityCount> hot_thresholds; - hot_thresholds.fill(NAN); - std::array<float, kThrottlingSeverityCount> cold_thresholds; - cold_thresholds.fill(NAN); - std::array<float, kThrottlingSeverityCount> hot_hysteresis; - hot_hysteresis.fill(0.0); - std::array<float, kThrottlingSeverityCount> cold_hysteresis; - cold_hysteresis.fill(0.0); - std::vector<std::string> linked_sensors; - std::vector<float> coefficients; - float offset = 0; - std::string trigger_sensor; - - FormulaOption formula = FormulaOption::COUNT_THRESHOLD; - bool is_virtual_sensor = false; - if (sensors[i]["VirtualSensor"].empty() || !sensors[i]["VirtualSensor"].isBool()) { - LOG(INFO) << "Failed to read Sensor[" << name << "]'s VirtualSensor, set to 'false'"; - } else { - is_virtual_sensor = sensors[i]["VirtualSensor"].asBool(); - } - Json::Value values = sensors[i]["HotThreshold"]; - if (!values.size()) { - LOG(INFO) << "Sensor[" << name << "]'s HotThreshold, default all to NAN"; - } else if (values.size() != kThrottlingSeverityCount) { - LOG(ERROR) << "Invalid " - << "Sensor[" << name << "]'s HotThreshold count:" << values.size(); - sensors_parsed->clear(); - return false; - } else { - float min = std::numeric_limits<float>::min(); - for (Json::Value::ArrayIndex j = 0; j < kThrottlingSeverityCount; ++j) { - hot_thresholds[j] = getFloatFromValue(values[j]); - if (!std::isnan(hot_thresholds[j])) { - if (hot_thresholds[j] < min) { - LOG(ERROR) << "Invalid " - << "Sensor[" << name << "]'s HotThreshold[j" << j - << "]: " << hot_thresholds[j] << " < " << min; - sensors_parsed->clear(); - return false; - } - min = hot_thresholds[j]; - } - LOG(INFO) << "Sensor[" << name << "]'s HotThreshold[" << j - << "]: " << hot_thresholds[j]; - } - } - - values = sensors[i]["HotHysteresis"]; - if (!values.size()) { - LOG(INFO) << "Sensor[" << name << "]'s HotHysteresis, default all to 0.0"; - } else if (values.size() != kThrottlingSeverityCount) { - LOG(ERROR) << "Invalid " - << "Sensor[" << name << "]'s HotHysteresis, count:" << values.size(); - sensors_parsed->clear(); - return false; - } else { - for (Json::Value::ArrayIndex j = 0; j < kThrottlingSeverityCount; ++j) { - hot_hysteresis[j] = getFloatFromValue(values[j]); - if (std::isnan(hot_hysteresis[j])) { - LOG(ERROR) << "Invalid " - << "Sensor[" << name << "]'s HotHysteresis: " << hot_hysteresis[j]; - sensors_parsed->clear(); - return false; - } - LOG(INFO) << "Sensor[" << name << "]'s HotHysteresis[" << j - << "]: " << hot_hysteresis[j]; - } - } - - for (Json::Value::ArrayIndex j = 0; j < (kThrottlingSeverityCount - 1); ++j) { - if (std::isnan(hot_thresholds[j])) { - continue; - } - for (auto k = j + 1; k < kThrottlingSeverityCount; ++k) { - if (std::isnan(hot_thresholds[k])) { - continue; - } else if (hot_thresholds[j] > (hot_thresholds[k] - hot_hysteresis[k])) { - LOG(ERROR) << "Sensor[" << name << "]'s hot threshold " << j - << " is overlapped"; - sensors_parsed->clear(); - return false; - } else { - break; - } - } - } - - values = sensors[i]["ColdThreshold"]; - if (!values.size()) { - LOG(INFO) << "Sensor[" << name << "]'s ColdThreshold, default all to NAN"; - } else if (values.size() != kThrottlingSeverityCount) { - LOG(ERROR) << "Invalid " - << "Sensor[" << name << "]'s ColdThreshold count:" << values.size(); - sensors_parsed->clear(); - return false; - } else { - float max = std::numeric_limits<float>::max(); - for (Json::Value::ArrayIndex j = 0; j < kThrottlingSeverityCount; ++j) { - cold_thresholds[j] = getFloatFromValue(values[j]); - if (!std::isnan(cold_thresholds[j])) { - if (cold_thresholds[j] > max) { - LOG(ERROR) << "Invalid " - << "Sensor[" << name << "]'s ColdThreshold[j" << j - << "]: " << cold_thresholds[j] << " > " << max; - sensors_parsed->clear(); - return false; - } - max = cold_thresholds[j]; - } - LOG(INFO) << "Sensor[" << name << "]'s ColdThreshold[" << j - << "]: " << cold_thresholds[j]; - } - } - - values = sensors[i]["ColdHysteresis"]; - if (!values.size()) { - LOG(INFO) << "Sensor[" << name << "]'s ColdHysteresis, default all to 0.0"; - } else if (values.size() != kThrottlingSeverityCount) { - LOG(ERROR) << "Invalid " - << "Sensor[" << name << "]'s ColdHysteresis count:" << values.size(); - sensors_parsed->clear(); - return false; - } else { - for (Json::Value::ArrayIndex j = 0; j < kThrottlingSeverityCount; ++j) { - cold_hysteresis[j] = getFloatFromValue(values[j]); - if (std::isnan(cold_hysteresis[j])) { - LOG(ERROR) << "Invalid " - << "Sensor[" << name << "]'s ColdHysteresis: " << cold_hysteresis[j]; - sensors_parsed->clear(); - return false; - } - LOG(INFO) << "Sensor[" << name << "]'s ColdHysteresis[" << j - << "]: " << cold_hysteresis[j]; - } - } - - for (Json::Value::ArrayIndex j = 0; j < (kThrottlingSeverityCount - 1); ++j) { - if (std::isnan(cold_thresholds[j])) { - continue; - } - for (auto k = j + 1; k < kThrottlingSeverityCount; ++k) { - if (std::isnan(cold_thresholds[k])) { - continue; - } else if (cold_thresholds[j] < (cold_thresholds[k] + cold_hysteresis[k])) { - LOG(ERROR) << "Sensor[" << name << "]'s cold threshold " << j - << " is overlapped"; - sensors_parsed->clear(); - return false; - } else { - break; - } - } - } - - if (is_virtual_sensor) { - values = sensors[i]["Combination"]; - if (values.size()) { - linked_sensors.reserve(values.size()); - for (Json::Value::ArrayIndex j = 0; j < values.size(); ++j) { - linked_sensors.emplace_back(values[j].asString()); - LOG(INFO) << "Sensor[" << name << "]'s combination[" << j - << "]: " << linked_sensors[j]; - } - } else { - LOG(ERROR) << "Sensor[" << name << "] has no combination setting"; - sensors_parsed->clear(); - return false; - } - - values = sensors[i]["Coefficient"]; - if (values.size()) { - coefficients.reserve(values.size()); - for (Json::Value::ArrayIndex j = 0; j < values.size(); ++j) { - coefficients.emplace_back(getFloatFromValue(values[j])); - LOG(INFO) << "Sensor[" << name << "]'s coefficient[" << j - << "]: " << coefficients[j]; - } - } else { - LOG(ERROR) << "Sensor[" << name << "] has no coefficient setting"; - sensors_parsed->clear(); - return false; - } - - if (linked_sensors.size() != coefficients.size()) { - LOG(ERROR) << "Sensor[" << name - << "]'s combination size is not matched with coefficient size"; - sensors_parsed->clear(); - return false; - } - - if (!sensors[i]["Offset"].empty()) { - offset = sensors[i]["Offset"].asFloat(); - } - - trigger_sensor = sensors[i]["TriggerSensor"].asString(); - if (sensors[i]["Formula"].asString().compare("COUNT_THRESHOLD") == 0) { - formula = FormulaOption::COUNT_THRESHOLD; - } else if (sensors[i]["Formula"].asString().compare("WEIGHTED_AVG") == 0) { - formula = FormulaOption::WEIGHTED_AVG; - } else if (sensors[i]["Formula"].asString().compare("MAXIMUM") == 0) { - formula = FormulaOption::MAXIMUM; - } else if (sensors[i]["Formula"].asString().compare("MINIMUM") == 0) { - formula = FormulaOption::MINIMUM; - } else { - LOG(ERROR) << "Sensor[" << name << "]'s Formula is invalid"; - sensors_parsed->clear(); - return false; - } - } - - std::string temp_path; - if (!sensors[i]["TempPath"].empty()) { - temp_path = sensors[i]["TempPath"].asString(); - LOG(INFO) << "Sensor[" << name << "]'s TempPath: " << temp_path; - } - - float vr_threshold = NAN; - if (!sensors[i]["VrThreshold"].empty()) { - vr_threshold = getFloatFromValue(sensors[i]["VrThreshold"]); - LOG(INFO) << "Sensor[" << name << "]'s VrThreshold: " << vr_threshold; - } - float multiplier = sensors[i]["Multiplier"].asFloat(); - LOG(INFO) << "Sensor[" << name << "]'s Multiplier: " << multiplier; - - std::chrono::milliseconds polling_delay = kUeventPollTimeoutMs; - if (!sensors[i]["PollingDelay"].empty()) { - const auto value = getIntFromValue(sensors[i]["PollingDelay"]); - polling_delay = (value > 0) ? std::chrono::milliseconds(value) - : std::chrono::milliseconds::max(); - } - LOG(INFO) << "Sensor[" << name << "]'s Polling delay: " << polling_delay.count(); - - std::chrono::milliseconds passive_delay = kMinPollIntervalMs; - if (!sensors[i]["PassiveDelay"].empty()) { - const auto value = getIntFromValue(sensors[i]["PassiveDelay"]); - passive_delay = (value > 0) ? std::chrono::milliseconds(value) - : std::chrono::milliseconds::max(); - } - LOG(INFO) << "Sensor[" << name << "]'s Passive delay: " << passive_delay.count(); - - std::chrono::milliseconds time_resolution; - if (sensors[i]["TimeResolution"].empty()) { - time_resolution = kMinPollIntervalMs; - } else { - time_resolution = - std::chrono::milliseconds(getIntFromValue(sensors[i]["TimeResolution"])); - } - LOG(INFO) << "Sensor[" << name << "]'s Time resolution: " << time_resolution.count(); - - bool support_pid = false; - std::array<float, kThrottlingSeverityCount> k_po; - k_po.fill(0.0); - std::array<float, kThrottlingSeverityCount> k_pu; - k_pu.fill(0.0); - std::array<float, kThrottlingSeverityCount> k_i; - k_i.fill(0.0); - std::array<float, kThrottlingSeverityCount> k_d; - k_d.fill(0.0); - std::array<float, kThrottlingSeverityCount> i_max; - i_max.fill(NAN); - std::array<float, kThrottlingSeverityCount> max_alloc_power; - max_alloc_power.fill(NAN); - std::array<float, kThrottlingSeverityCount> min_alloc_power; - min_alloc_power.fill(NAN); - std::array<float, kThrottlingSeverityCount> s_power; - s_power.fill(NAN); - std::array<float, kThrottlingSeverityCount> i_cutoff; - i_cutoff.fill(NAN); - float err_integral_default = 0.0; - - // Parse PID parameters - if (!sensors[i]["PIDInfo"].empty()) { - LOG(INFO) << "Start to parse" - << " Sensor[" << name << "]'s K_Po"; - if (sensors[i]["PIDInfo"]["K_Po"].empty() || - !getFloatFromJsonValues(sensors[i]["PIDInfo"]["K_Po"], &k_po, false, false)) { - LOG(ERROR) << "Sensor[" << name << "]: Failed to parse K_Po"; - sensors_parsed->clear(); - return false; - } - LOG(INFO) << "Start to parse" - << " Sensor[" << name << "]'s K_Pu"; - if (sensors[i]["PIDInfo"]["K_Pu"].empty() || - !getFloatFromJsonValues(sensors[i]["PIDInfo"]["K_Pu"], &k_pu, false, false)) { - LOG(ERROR) << "Sensor[" << name << "]: Failed to parse K_Pu"; - sensors_parsed->clear(); - return false; - } - LOG(INFO) << "Start to parse" - << " Sensor[" << name << "]'s K_I"; - if (sensors[i]["PIDInfo"]["K_I"].empty() || - !getFloatFromJsonValues(sensors[i]["PIDInfo"]["K_I"], &k_i, false, false)) { - LOG(ERROR) << "Sensor[" << name << "]: Failed to parse K_I"; - sensors_parsed->clear(); - return false; - } - LOG(INFO) << "Start to parse" - << " Sensor[" << name << "]'s K_D"; - if (sensors[i]["PIDInfo"]["K_D"].empty() || - !getFloatFromJsonValues(sensors[i]["PIDInfo"]["K_D"], &k_d, false, false)) { - LOG(ERROR) << "Sensor[" << name << "]: Failed to parse K_D"; - sensors_parsed->clear(); - return false; - } - LOG(INFO) << "Start to parse" - << " Sensor[" << name << "]'s I_Max"; - if (sensors[i]["PIDInfo"]["I_Max"].empty() || - !getFloatFromJsonValues(sensors[i]["PIDInfo"]["I_Max"], &i_max, false, false)) { - LOG(ERROR) << "Sensor[" << name << "]: Failed to parse I_Max"; - sensors_parsed->clear(); - return false; - } - LOG(INFO) << "Start to parse" - << " Sensor[" << name << "]'s MaxAllocPower"; - if (sensors[i]["PIDInfo"]["MaxAllocPower"].empty() || - !getFloatFromJsonValues(sensors[i]["PIDInfo"]["MaxAllocPower"], &max_alloc_power, - false, true)) { - LOG(ERROR) << "Sensor[" << name << "]: Failed to parse MaxAllocPower"; - sensors_parsed->clear(); - return false; - } - LOG(INFO) << "Start to parse" - << " Sensor[" << name << "]'s MinAllocPower"; - if (sensors[i]["PIDInfo"]["MinAllocPower"].empty() || - !getFloatFromJsonValues(sensors[i]["PIDInfo"]["MinAllocPower"], &min_alloc_power, - false, true)) { - LOG(ERROR) << "Sensor[" << name << "]: Failed to parse MinAllocPower"; - sensors_parsed->clear(); - return false; - } - LOG(INFO) << "Start to parse" - << " Sensor[" << name << "]'s S_Power"; - if (sensors[i]["PIDInfo"]["S_Power"].empty() || - !getFloatFromJsonValues(sensors[i]["PIDInfo"]["S_Power"], &s_power, false, true)) { - LOG(ERROR) << "Sensor[" << name << "]: Failed to parse S_Power"; - sensors_parsed->clear(); - return false; - } - LOG(INFO) << "Start to parse" - << " Sensor[" << name << "]'s I_Cutoff"; - if (sensors[i]["PIDInfo"]["I_Cutoff"].empty() || - !getFloatFromJsonValues(sensors[i]["PIDInfo"]["I_Cutoff"], &i_cutoff, false, - false)) { - LOG(ERROR) << "Sensor[" << name << "]: Failed to parse I_Cutoff"; - sensors_parsed->clear(); - return false; - } - LOG(INFO) << "Start to parse" - << " Sensor[" << name << "]'s E_Integral_Default"; - err_integral_default = getFloatFromValue(sensors[i]["PIDInfo"]["E_Integral_Default"]); - LOG(INFO) << "Sensor[" << name << "]'s E_Integral_Default: " << err_integral_default; - // Confirm we have at least one valid PID combination - bool valid_pid_combination = false; - for (Json::Value::ArrayIndex j = 0; j < kThrottlingSeverityCount; ++j) { - if (!std::isnan(s_power[j])) { - if (std::isnan(k_po[j]) || std::isnan(k_pu[j]) || std::isnan(k_i[j]) || - std::isnan(k_d[j]) || std::isnan(i_max[j]) || - std::isnan(max_alloc_power[j]) || std::isnan(min_alloc_power[j]) || - std::isnan(i_cutoff[j])) { - valid_pid_combination = false; - break; - } else { - valid_pid_combination = true; - } - } - } - if (!valid_pid_combination) { - LOG(ERROR) << "Sensor[" << name << "]: Invalid PID parameters combinations"; - sensors_parsed->clear(); - return false; - } else { - support_pid = true; - } - } - - // Parse binded cooling device - bool support_hard_limit = false; - std::unordered_map<std::string, BindedCdevInfo> binded_cdev_info_map; - values = sensors[i]["BindedCdevInfo"]; - for (Json::Value::ArrayIndex j = 0; j < values.size(); ++j) { - Json::Value sub_values; - const std::string &cdev_name = values[j]["CdevRequest"].asString(); - ThrottlingArray cdev_weight_for_pid; - cdev_weight_for_pid.fill(NAN); - CdevArray cdev_ceiling; - cdev_ceiling.fill(std::numeric_limits<int>::max()); - int max_release_step = std::numeric_limits<int>::max(); - int max_throttle_step = std::numeric_limits<int>::max(); - if (support_pid) { - if (!values[j]["CdevWeightForPID"].empty()) { - LOG(INFO) << "Sensor[" << name << "]: Star to parse " << cdev_name - << "'s CdevWeightForPID"; - if (!getFloatFromJsonValues(values[j]["CdevWeightForPID"], &cdev_weight_for_pid, - false, false)) { - LOG(ERROR) << "Failed to parse CdevWeightForPID"; - sensors_parsed->clear(); - return false; - } - } - if (!values[j]["CdevCeiling"].empty()) { - LOG(INFO) << "Sensor[" << name - << "]: Start to parse CdevCeiling: " << cdev_name; - if (!getIntFromJsonValues(values[j]["CdevCeiling"], &cdev_ceiling, false, - false)) { - LOG(ERROR) << "Failed to parse CdevCeiling"; - sensors_parsed->clear(); - return false; - } - } - if (!values[j]["MaxReleaseStep"].empty()) { - max_release_step = getIntFromValue(values[j]["MaxReleaseStep"]); - if (max_release_step < 0) { - LOG(ERROR) << "Sensor[" << name << "]'s " << cdev_name - << " MaxReleaseStep: " << max_release_step; - sensors_parsed->clear(); - return false; - } else { - LOG(INFO) << "Sensor[" << name << "]'s " << cdev_name - << " MaxReleaseStep: " << max_release_step; - } - } - if (!values[j]["MaxThrottleStep"].empty()) { - max_throttle_step = getIntFromValue(values[j]["MaxThrottleStep"]); - if (max_throttle_step < 0) { - LOG(ERROR) << "Sensor[" << name << "]'s " << cdev_name - << " MaxThrottleStep: " << max_throttle_step; - sensors_parsed->clear(); - return false; - } else { - LOG(INFO) << "Sensor[" << name << "]'s " << cdev_name - << " MaxThrottleStep: " << max_throttle_step; - } - } - } - CdevArray limit_info; - limit_info.fill(0); - ThrottlingArray power_thresholds; - power_thresholds.fill(NAN); - - ReleaseLogic release_logic = ReleaseLogic::NONE; - - sub_values = values[j]["LimitInfo"]; - if (sub_values.size()) { - LOG(INFO) << "Sensor[" << name << "]: Start to parse LimitInfo: " << cdev_name; - if (!getIntFromJsonValues(sub_values, &limit_info, false, false)) { - LOG(ERROR) << "Failed to parse LimitInfo"; - sensors_parsed->clear(); - return false; - } - support_hard_limit = true; - } - - // Parse linked power info - std::string power_rail; - bool high_power_check = false; - bool throttling_with_power_link = false; - CdevArray cdev_floor_with_power_link; - cdev_floor_with_power_link.fill(0); - - const bool power_link_disabled = - android::base::GetBoolProperty(kPowerLinkDisabledProperty.data(), false); - if (!power_link_disabled) { - power_rail = values[j]["BindedPowerRail"].asString(); - - if (values[j]["HighPowerCheck"].asBool()) { - high_power_check = true; - } - LOG(INFO) << "Highpowercheck: " << std::boolalpha << high_power_check; - - if (values[j]["ThrottlingWithPowerLink"].asBool()) { - throttling_with_power_link = true; - } - LOG(INFO) << "ThrottlingwithPowerLink: " << std::boolalpha - << throttling_with_power_link; - - sub_values = values[j]["CdevFloorWithPowerLink"]; - if (sub_values.size()) { - LOG(INFO) << "Sensor[" << name << "]: Start to parse " << cdev_name - << "'s CdevFloorWithPowerLink"; - if (!getIntFromJsonValues(sub_values, &cdev_floor_with_power_link, false, - false)) { - LOG(ERROR) << "Failed to parse CdevFloor"; - sensors_parsed->clear(); - return false; - } - } - sub_values = values[j]["PowerThreshold"]; - if (sub_values.size()) { - LOG(INFO) << "Sensor[" << name << "]: Start to parse " << cdev_name - << "'s PowerThreshold"; - if (!getFloatFromJsonValues(sub_values, &power_thresholds, false, false)) { - LOG(ERROR) << "Failed to parse power thresholds"; - sensors_parsed->clear(); - return false; - } - if (values[j]["ReleaseLogic"].asString() == "INCREASE") { - release_logic = ReleaseLogic::INCREASE; - LOG(INFO) << "Release logic: INCREASE"; - } else if (values[j]["ReleaseLogic"].asString() == "DECREASE") { - release_logic = ReleaseLogic::DECREASE; - LOG(INFO) << "Release logic: DECREASE"; - } else if (values[j]["ReleaseLogic"].asString() == "STEPWISE") { - release_logic = ReleaseLogic::STEPWISE; - LOG(INFO) << "Release logic: STEPWISE"; - } else if (values[j]["ReleaseLogic"].asString() == "RELEASE_TO_FLOOR") { - release_logic = ReleaseLogic::RELEASE_TO_FLOOR; - LOG(INFO) << "Release logic: RELEASE_TO_FLOOR"; - } else { - LOG(ERROR) << "Release logic is invalid"; - sensors_parsed->clear(); - return false; - } - } - } - - binded_cdev_info_map[cdev_name] = { - .limit_info = limit_info, - .power_thresholds = power_thresholds, - .release_logic = release_logic, - .high_power_check = high_power_check, - .throttling_with_power_link = throttling_with_power_link, - .cdev_weight_for_pid = cdev_weight_for_pid, - .cdev_ceiling = cdev_ceiling, - .max_release_step = max_release_step, - .max_throttle_step = max_throttle_step, - .cdev_floor_with_power_link = cdev_floor_with_power_link, - .power_rail = power_rail, - }; - } - - if (is_hidden && send_cb) { - LOG(ERROR) << "is_hidden and send_cb cannot be enabled together"; - sensors_parsed->clear(); - return false; - } - - bool is_watch = (send_cb | send_powerhint | support_pid | support_hard_limit); - LOG(INFO) << "Sensor[" << name << "]'s is_watch: " << std::boolalpha << is_watch; - - std::unique_ptr<VirtualSensorInfo> virtual_sensor_info; - if (is_virtual_sensor) { - virtual_sensor_info.reset(new VirtualSensorInfo{linked_sensors, coefficients, offset, - trigger_sensor, formula}); - } - - std::shared_ptr<ThrottlingInfo> throttling_info( - new ThrottlingInfo{k_po, k_pu, k_i, k_d, i_max, max_alloc_power, min_alloc_power, - s_power, i_cutoff, err_integral_default, binded_cdev_info_map}); - - (*sensors_parsed)[name] = { - .type = sensor_type, - .hot_thresholds = hot_thresholds, - .cold_thresholds = cold_thresholds, - .hot_hysteresis = hot_hysteresis, - .cold_hysteresis = cold_hysteresis, - .temp_path = temp_path, - .vr_threshold = vr_threshold, - .multiplier = multiplier, - .polling_delay = polling_delay, - .passive_delay = passive_delay, - .time_resolution = time_resolution, - .send_cb = send_cb, - .send_powerhint = send_powerhint, - .is_watch = is_watch, - .is_hidden = is_hidden, - .virtual_sensor_info = std::move(virtual_sensor_info), - .throttling_info = std::move(throttling_info), - }; - - ++total_parsed; - } - LOG(INFO) << total_parsed << " Sensors parsed successfully"; - return true; -} - -bool ParseCoolingDevice(std::string_view config_path, - std::unordered_map<std::string, CdevInfo> *cooling_devices_parsed) { - std::string json_doc; - if (!android::base::ReadFileToString(config_path.data(), &json_doc)) { - LOG(ERROR) << "Failed to read JSON config from " << config_path; - return false; - } - Json::Value root; - Json::CharReaderBuilder builder; - std::unique_ptr<Json::CharReader> reader(builder.newCharReader()); - std::string errorMessage; - - if (!reader->parse(&*json_doc.begin(), &*json_doc.end(), &root, &errorMessage)) { - LOG(ERROR) << "Failed to parse JSON config: " << errorMessage; - return false; - } - - Json::Value cooling_devices = root["CoolingDevices"]; - std::size_t total_parsed = 0; - std::unordered_set<std::string> cooling_devices_name_parsed; - - for (Json::Value::ArrayIndex i = 0; i < cooling_devices.size(); ++i) { - const std::string &name = cooling_devices[i]["Name"].asString(); - LOG(INFO) << "CoolingDevice[" << i << "]'s Name: " << name; - if (name.empty()) { - LOG(ERROR) << "Failed to read " - << "CoolingDevice[" << i << "]'s Name"; - cooling_devices_parsed->clear(); - return false; - } - - auto result = cooling_devices_name_parsed.insert(name.data()); - if (!result.second) { - LOG(ERROR) << "Duplicate CoolingDevice[" << i << "]'s Name"; - cooling_devices_parsed->clear(); - return false; - } - - std::string cooling_device_type_str = cooling_devices[i]["Type"].asString(); - LOG(INFO) << "CoolingDevice[" << name << "]'s Type: " << cooling_device_type_str; - CoolingType cooling_device_type; - - if (!getTypeFromString(cooling_device_type_str, &cooling_device_type)) { - LOG(ERROR) << "Invalid " - << "CoolingDevice[" << name << "]'s Type: " << cooling_device_type_str; - cooling_devices_parsed->clear(); - return false; - } - - const std::string &read_path = cooling_devices[i]["ReadPath"].asString(); - LOG(INFO) << "Cdev Read Path: " << (read_path.empty() ? "default" : read_path); - - const std::string &write_path = cooling_devices[i]["WritePath"].asString(); - LOG(INFO) << "Cdev Write Path: " << (write_path.empty() ? "default" : write_path); - - std::vector<float> state2power; - Json::Value values = cooling_devices[i]["State2Power"]; - if (values.size()) { - state2power.reserve(values.size()); - for (Json::Value::ArrayIndex j = 0; j < values.size(); ++j) { - state2power.emplace_back(getFloatFromValue(values[j])); - LOG(INFO) << "Cooling device[" << name << "]'s Power2State[" << j - << "]: " << state2power[j]; - } - } else { - LOG(INFO) << "CoolingDevice[" << i << "]'s Name: " << name - << " does not support State2Power"; - } - - const std::string &power_rail = cooling_devices[i]["PowerRail"].asString(); - LOG(INFO) << "Cooling device power rail : " << power_rail; - - (*cooling_devices_parsed)[name] = { - .type = cooling_device_type, - .read_path = read_path, - .write_path = write_path, - .state2power = state2power, - }; - ++total_parsed; - } - LOG(INFO) << total_parsed << " CoolingDevices parsed successfully"; - return true; -} - -bool ParsePowerRailInfo(std::string_view config_path, - std::unordered_map<std::string, PowerRailInfo> *power_rails_parsed) { - std::string json_doc; - if (!android::base::ReadFileToString(config_path.data(), &json_doc)) { - LOG(ERROR) << "Failed to read JSON config from " << config_path; - return false; - } - Json::Value root; - Json::CharReaderBuilder builder; - std::unique_ptr<Json::CharReader> reader(builder.newCharReader()); - std::string errorMessage; - - if (!reader->parse(&*json_doc.begin(), &*json_doc.end(), &root, &errorMessage)) { - LOG(ERROR) << "Failed to parse JSON config: " << errorMessage; - return false; - } - - Json::Value power_rails = root["PowerRails"]; - std::size_t total_parsed = 0; - std::unordered_set<std::string> power_rails_name_parsed; - - for (Json::Value::ArrayIndex i = 0; i < power_rails.size(); ++i) { - const std::string &name = power_rails[i]["Name"].asString(); - LOG(INFO) << "PowerRail[" << i << "]'s Name: " << name; - if (name.empty()) { - LOG(ERROR) << "Failed to read " - << "PowerRail[" << i << "]'s Name"; - power_rails_parsed->clear(); - return false; - } - - std::string rail; - if (power_rails[i]["Rail"].empty()) { - rail = name; - } else { - rail = power_rails[i]["Rail"].asString(); - } - LOG(INFO) << "PowerRail[" << i << "]'s Rail: " << rail; - - std::vector<std::string> linked_power_rails; - std::vector<float> coefficients; - float offset = 0; - FormulaOption formula = FormulaOption::COUNT_THRESHOLD; - bool is_virtual_power_rail = false; - Json::Value values; - int power_sample_count = 0; - std::chrono::milliseconds power_sample_delay; - - if (!power_rails[i]["VirtualRails"].empty() && power_rails[i]["VirtualRails"].isBool()) { - is_virtual_power_rail = power_rails[i]["VirtualRails"].asBool(); - LOG(INFO) << "PowerRails[" << name << "]'s VirtualRail, set to 'true'"; - } - - if (is_virtual_power_rail) { - values = power_rails[i]["Combination"]; - if (values.size()) { - linked_power_rails.reserve(values.size()); - for (Json::Value::ArrayIndex j = 0; j < values.size(); ++j) { - linked_power_rails.emplace_back(values[j].asString()); - LOG(INFO) << "PowerRail[" << name << "]'s combination[" << j - << "]: " << linked_power_rails[j]; - } - } else { - LOG(ERROR) << "PowerRails[" << name << "] has no combination for VirtualRail"; - power_rails_parsed->clear(); - return false; - } - - values = power_rails[i]["Coefficient"]; - if (values.size()) { - coefficients.reserve(values.size()); - for (Json::Value::ArrayIndex j = 0; j < values.size(); ++j) { - coefficients.emplace_back(getFloatFromValue(values[j])); - LOG(INFO) << "PowerRail[" << name << "]'s coefficient[" << j - << "]: " << coefficients[j]; - } - } else { - LOG(ERROR) << "PowerRails[" << name << "] has no coefficient for VirtualRail"; - power_rails_parsed->clear(); - return false; - } - - if (linked_power_rails.size() != coefficients.size()) { - LOG(ERROR) << "PowerRails[" << name - << "]'s combination size is not matched with coefficient size"; - power_rails_parsed->clear(); - return false; - } - - if (!power_rails[i]["Offset"].empty()) { - offset = power_rails[i]["Offset"].asFloat(); - } - - if (linked_power_rails.size() != coefficients.size()) { - LOG(ERROR) << "PowerRails[" << name - << "]'s combination size is not matched with coefficient size"; - power_rails_parsed->clear(); - return false; - } - - if (power_rails[i]["Formula"].asString().compare("COUNT_THRESHOLD") == 0) { - formula = FormulaOption::COUNT_THRESHOLD; - } else if (power_rails[i]["Formula"].asString().compare("WEIGHTED_AVG") == 0) { - formula = FormulaOption::WEIGHTED_AVG; - } else if (power_rails[i]["Formula"].asString().compare("MAXIMUM") == 0) { - formula = FormulaOption::MAXIMUM; - } else if (power_rails[i]["Formula"].asString().compare("MINIMUM") == 0) { - formula = FormulaOption::MINIMUM; - } else { - LOG(ERROR) << "PowerRails[" << name << "]'s Formula is invalid"; - power_rails_parsed->clear(); - return false; - } - } - - std::unique_ptr<VirtualPowerRailInfo> virtual_power_rail_info; - if (is_virtual_power_rail) { - virtual_power_rail_info.reset( - new VirtualPowerRailInfo{linked_power_rails, coefficients, offset, formula}); - } - - power_sample_count = power_rails[i]["PowerSampleCount"].asInt(); - LOG(INFO) << "Power sample Count: " << power_sample_count; - - if (!power_rails[i]["PowerSampleDelay"]) { - power_sample_delay = std::chrono::milliseconds::max(); - } else { - power_sample_delay = - std::chrono::milliseconds(getIntFromValue(power_rails[i]["PowerSampleDelay"])); - } - - (*power_rails_parsed)[name] = { - .rail = rail, - .power_sample_count = power_sample_count, - .power_sample_delay = power_sample_delay, - .virtual_power_rail_info = std::move(virtual_power_rail_info), - }; - ++total_parsed; - } - LOG(INFO) << total_parsed << " PowerRails parsed successfully"; - return true; -} - -} // namespace implementation -} // namespace V2_0 -} // namespace thermal -} // namespace hardware -} // namespace android diff --git a/thermal/pid_1_0/utils/thermal_info.h b/thermal/pid_1_0/utils/thermal_info.h deleted file mode 100644 index 84d04026..00000000 --- a/thermal/pid_1_0/utils/thermal_info.h +++ /dev/null @@ -1,148 +0,0 @@ -/* - * Copyright (C) 2018 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. - */ - -#pragma once - -#include <android/hardware/thermal/2.0/IThermal.h> - -#include <string> -#include <unordered_map> - -namespace android { -namespace hardware { -namespace thermal { -namespace V2_0 { -namespace implementation { - -using ::android::hardware::hidl_enum_range; -using CoolingType_2_0 = ::android::hardware::thermal::V2_0::CoolingType; -using TemperatureType_2_0 = ::android::hardware::thermal::V2_0::TemperatureType; -using ::android::hardware::thermal::V2_0::ThrottlingSeverity; -constexpr size_t kThrottlingSeverityCount = std::distance( - hidl_enum_range<ThrottlingSeverity>().begin(), hidl_enum_range<ThrottlingSeverity>().end()); -using ThrottlingArray = std::array<float, static_cast<size_t>(kThrottlingSeverityCount)>; -using CdevArray = std::array<int, static_cast<size_t>(kThrottlingSeverityCount)>; -constexpr std::chrono::milliseconds kMinPollIntervalMs = std::chrono::milliseconds(2000); -constexpr std::chrono::milliseconds kUeventPollTimeoutMs = std::chrono::milliseconds(300000); - -enum FormulaOption : uint32_t { - COUNT_THRESHOLD = 0, - WEIGHTED_AVG, - MAXIMUM, - MINIMUM, -}; - -struct VirtualSensorInfo { - std::vector<std::string> linked_sensors; - std::vector<float> coefficients; - float offset; - std::string trigger_sensor; - FormulaOption formula; -}; - -struct VirtualPowerRailInfo { - std::vector<std::string> linked_power_rails; - std::vector<float> coefficients; - float offset; - FormulaOption formula; -}; - -// The method when the ODPM power is lower than threshold -enum ReleaseLogic : uint32_t { - INCREASE = 0, // Increase throttling by step - DECREASE, // Decrease throttling by step - STEPWISE, // Support both increase and decrease logix - RELEASE_TO_FLOOR, // Release throttling to floor directly - NONE, -}; - -struct BindedCdevInfo { - CdevArray limit_info; - ThrottlingArray power_thresholds; - ReleaseLogic release_logic; - ThrottlingArray cdev_weight_for_pid; - CdevArray cdev_ceiling; - int max_release_step; - int max_throttle_step; - CdevArray cdev_floor_with_power_link; - std::string power_rail; - // The flag for activate release logic when power is higher than power threshold - bool high_power_check; - // The flag for only triggering throttling until all power samples are collected - bool throttling_with_power_link; -}; - -struct ThrottlingInfo { - ThrottlingArray k_po; - ThrottlingArray k_pu; - ThrottlingArray k_i; - ThrottlingArray k_d; - ThrottlingArray i_max; - ThrottlingArray max_alloc_power; - ThrottlingArray min_alloc_power; - ThrottlingArray s_power; - ThrottlingArray i_cutoff; - float err_integral_default; - std::unordered_map<std::string, BindedCdevInfo> binded_cdev_info_map; -}; - -struct SensorInfo { - TemperatureType_2_0 type; - ThrottlingArray hot_thresholds; - ThrottlingArray cold_thresholds; - ThrottlingArray hot_hysteresis; - ThrottlingArray cold_hysteresis; - std::string temp_path; - float vr_threshold; - float multiplier; - std::chrono::milliseconds polling_delay; - std::chrono::milliseconds passive_delay; - std::chrono::milliseconds time_resolution; - bool send_cb; - bool send_powerhint; - bool is_watch; - bool is_hidden; - std::unique_ptr<VirtualSensorInfo> virtual_sensor_info; - std::shared_ptr<ThrottlingInfo> throttling_info; -}; - -struct CdevInfo { - CoolingType_2_0 type; - std::string read_path; - std::string write_path; - std::vector<float> state2power; - int max_state; -}; - -struct PowerRailInfo { - std::string rail; - int power_sample_count; - std::chrono::milliseconds power_sample_delay; - std::unique_ptr<VirtualPowerRailInfo> virtual_power_rail_info; -}; - -bool ParseSensorInfo(std::string_view config_path, - std::unordered_map<std::string, SensorInfo> *sensors_parsed); -bool ParseCoolingDevice(std::string_view config_path, - std::unordered_map<std::string, CdevInfo> *cooling_device_parsed); -bool ParsePowerRailInfo(std::string_view config_path, - std::unordered_map<std::string, PowerRailInfo> *power_rail_parsed); - -} // namespace implementation -} // namespace V2_0 -} // namespace thermal -} // namespace hardware -} // namespace android diff --git a/thermal/pid_1_0/utils/thermal_throttling.cpp b/thermal/pid_1_0/utils/thermal_throttling.cpp deleted file mode 100644 index 53075cee..00000000 --- a/thermal/pid_1_0/utils/thermal_throttling.cpp +++ /dev/null @@ -1,448 +0,0 @@ -/* - * Copyright (C) 2022 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. - */ - -#include "thermal_throttling.h" - -#include <android-base/file.h> -#include <android-base/logging.h> -#include <android-base/properties.h> -#include <android-base/stringprintf.h> -#include <android-base/strings.h> -#include <utils/Trace.h> - -#include <iterator> -#include <set> -#include <sstream> -#include <thread> -#include <vector> - -namespace android { -namespace hardware { -namespace thermal { -namespace V2_0 { -namespace implementation { - -// To find the next PID target state according to the current thermal severity -size_t getTargetStateOfPID(const SensorInfo &sensor_info, const ThrottlingSeverity curr_severity) { - size_t target_state = 0; - - for (const auto &severity : hidl_enum_range<ThrottlingSeverity>()) { - size_t state = static_cast<size_t>(severity); - if (std::isnan(sensor_info.throttling_info->s_power[state])) { - continue; - } - target_state = state; - if (severity > curr_severity) { - break; - } - } - LOG(VERBOSE) << "PID target state = " << target_state; - return target_state; -} - -void ThermalThrottling::clearThrottlingData(std::string_view sensor_name, - const SensorInfo &sensor_info) { - if (!thermal_throttling_status_map_.count(sensor_name.data())) { - return; - } - std::unique_lock<std::shared_mutex> _lock(thermal_throttling_status_map_mutex_); - - for (auto &pid_power_budget_pair : - thermal_throttling_status_map_.at(sensor_name.data()).pid_power_budget_map) { - pid_power_budget_pair.second = std::numeric_limits<int>::max(); - } - - for (auto &pid_cdev_request_pair : - thermal_throttling_status_map_.at(sensor_name.data()).pid_cdev_request_map) { - pid_cdev_request_pair.second = 0; - } - - for (auto &hardlimit_cdev_request_pair : - thermal_throttling_status_map_.at(sensor_name.data()).hardlimit_cdev_request_map) { - hardlimit_cdev_request_pair.second = 0; - } - - for (auto &throttling_release_pair : - thermal_throttling_status_map_.at(sensor_name.data()).throttling_release_map) { - throttling_release_pair.second = 0; - } - - thermal_throttling_status_map_[sensor_name.data()].err_integral = - sensor_info.throttling_info->err_integral_default; - thermal_throttling_status_map_[sensor_name.data()].prev_err = NAN; - return; -} - -bool ThermalThrottling::registerThermalThrottling( - std::string_view sensor_name, const std::shared_ptr<ThrottlingInfo> &throttling_info, - const std::unordered_map<std::string, CdevInfo> &cooling_device_info_map) { - if (thermal_throttling_status_map_.count(sensor_name.data())) { - LOG(ERROR) << "Sensor " << sensor_name.data() << " throttling map has been registered"; - return false; - } - - if (throttling_info == nullptr) { - LOG(ERROR) << "Sensor " << sensor_name.data() << " has no throttling info"; - return false; - } - thermal_throttling_status_map_[sensor_name.data()].err_integral = - throttling_info->err_integral_default; - thermal_throttling_status_map_[sensor_name.data()].prev_err = NAN; - - for (auto &binded_cdev_pair : throttling_info->binded_cdev_info_map) { - if (!cooling_device_info_map.count(binded_cdev_pair.first)) { - LOG(ERROR) << "Could not find " << sensor_name.data() << "'s binded CDEV " - << binded_cdev_pair.first; - return false; - } - // Register PID throttling map - for (const auto &cdev_weight : binded_cdev_pair.second.cdev_weight_for_pid) { - if (!std::isnan(cdev_weight)) { - thermal_throttling_status_map_[sensor_name.data()] - .pid_power_budget_map[binded_cdev_pair.first] = - std::numeric_limits<int>::max(); - thermal_throttling_status_map_[sensor_name.data()] - .pid_cdev_request_map[binded_cdev_pair.first] = 0; - thermal_throttling_status_map_[sensor_name.data()] - .cdev_status_map[binded_cdev_pair.first] = 0; - break; - } - } - // Register hard limit throttling map - for (const auto &limit_info : binded_cdev_pair.second.limit_info) { - if (limit_info > 0) { - thermal_throttling_status_map_[sensor_name.data()] - .hardlimit_cdev_request_map[binded_cdev_pair.first] = 0; - thermal_throttling_status_map_[sensor_name.data()] - .cdev_status_map[binded_cdev_pair.first] = 0; - break; - } - } - // Register throttling release map if power threshold is exist - if (!binded_cdev_pair.second.power_rail.empty()) { - for (const auto &power_threshold : binded_cdev_pair.second.power_thresholds) { - if (!std::isnan(power_threshold)) { - thermal_throttling_status_map_[sensor_name.data()] - .throttling_release_map[binded_cdev_pair.first] = 0; - break; - } - } - } - } - return true; -} - -// return power budget based on PID algo -float ThermalThrottling::updatePowerBudget(const Temperature_2_0 &temp, - const SensorInfo &sensor_info, - std::chrono::milliseconds time_elapsed_ms, - ThrottlingSeverity curr_severity) { - float p = 0, i = 0, d = 0; - float power_budget = std::numeric_limits<float>::max(); - - if (curr_severity == ThrottlingSeverity::NONE) { - return power_budget; - } - - const auto target_state = getTargetStateOfPID(sensor_info, curr_severity); - - // Compute PID - float err = sensor_info.hot_thresholds[target_state] - temp.value; - p = err * (err < 0 ? sensor_info.throttling_info->k_po[target_state] - : sensor_info.throttling_info->k_pu[target_state]); - i = thermal_throttling_status_map_[temp.name].err_integral * - sensor_info.throttling_info->k_i[target_state]; - if (err < sensor_info.throttling_info->i_cutoff[target_state]) { - float i_next = i + err * sensor_info.throttling_info->k_i[target_state]; - if (abs(i_next) < sensor_info.throttling_info->i_max[target_state]) { - i = i_next; - thermal_throttling_status_map_[temp.name].err_integral += err; - } - } - - if (!std::isnan(thermal_throttling_status_map_[temp.name].prev_err) && - time_elapsed_ms != std::chrono::milliseconds::zero()) { - d = sensor_info.throttling_info->k_d[target_state] * - (err - thermal_throttling_status_map_[temp.name].prev_err) / time_elapsed_ms.count(); - } - - thermal_throttling_status_map_[temp.name].prev_err = err; - // Calculate power budget - power_budget = sensor_info.throttling_info->s_power[target_state] + p + i + d; - if (power_budget < sensor_info.throttling_info->min_alloc_power[target_state]) { - power_budget = sensor_info.throttling_info->min_alloc_power[target_state]; - } - if (power_budget > sensor_info.throttling_info->max_alloc_power[target_state]) { - power_budget = sensor_info.throttling_info->max_alloc_power[target_state]; - } - - LOG(INFO) << temp.name << " power_budget=" << power_budget << " err=" << err - << " err_integral=" << thermal_throttling_status_map_[temp.name].err_integral - << " s_power=" << sensor_info.throttling_info->s_power[target_state] - << " time_elapsed_ms=" << time_elapsed_ms.count() << " p=" << p << " i=" << i - << " d=" << d << " control target=" << target_state; - - return power_budget; -} - -bool ThermalThrottling::updateCdevRequestByPower( - const Temperature_2_0 &temp, const SensorInfo &sensor_info, - const ThrottlingSeverity curr_severity, const std::chrono::milliseconds time_elapsed_ms, - const std::unordered_map<std::string, CdevInfo> &cooling_device_info_map) { - float total_weight = 0, cdev_power_budget; - size_t j; - - const auto target_state = getTargetStateOfPID(sensor_info, curr_severity); - auto total_power_budget = updatePowerBudget(temp, sensor_info, time_elapsed_ms, curr_severity); - - std::unique_lock<std::shared_mutex> _lock(thermal_throttling_status_map_mutex_); - // Compute total cdev weight - for (const auto &binded_cdev_info_pair : sensor_info.throttling_info->binded_cdev_info_map) { - const auto cdev_weight = binded_cdev_info_pair.second - .cdev_weight_for_pid[static_cast<size_t>(curr_severity)]; - if (std::isnan(cdev_weight)) { - continue; - } - total_weight += cdev_weight; - } - - // Map cdev state by power - for (const auto &binded_cdev_info_pair : sensor_info.throttling_info->binded_cdev_info_map) { - const auto cdev_weight = binded_cdev_info_pair.second.cdev_weight_for_pid[target_state]; - if (!std::isnan(cdev_weight)) { - cdev_power_budget = total_power_budget * (cdev_weight / total_weight); - - const CdevInfo &cdev_info_pair = - cooling_device_info_map.at(binded_cdev_info_pair.first); - for (j = 0; j < cdev_info_pair.state2power.size() - 1; ++j) { - if (cdev_power_budget > cdev_info_pair.state2power[j]) { - break; - } - } - - thermal_throttling_status_map_[temp.name].pid_cdev_request_map.at( - binded_cdev_info_pair.first) = static_cast<int>(j); - LOG(VERBOSE) << "Power allocator: Sensor " << temp.name << " allocate " - << cdev_power_budget << "mW to " << binded_cdev_info_pair.first - << "(cdev_weight=" << cdev_weight << ") update state to " << j; - } - } - return true; -} - -void ThermalThrottling::updateCdevRequestBySeverity(std::string_view sensor_name, - const SensorInfo &sensor_info, - ThrottlingSeverity curr_severity) { - std::unique_lock<std::shared_mutex> _lock(thermal_throttling_status_map_mutex_); - for (auto const &binded_cdev_info_pair : sensor_info.throttling_info->binded_cdev_info_map) { - thermal_throttling_status_map_[sensor_name.data()].hardlimit_cdev_request_map.at( - binded_cdev_info_pair.first) = - binded_cdev_info_pair.second.limit_info[static_cast<size_t>(curr_severity)]; - LOG(VERBOSE) << "Hard Limit: Sensor " << sensor_name.data() << " update cdev " - << binded_cdev_info_pair.first << " to " - << thermal_throttling_status_map_[sensor_name.data()] - .hardlimit_cdev_request_map.at(binded_cdev_info_pair.first); - } -} - -bool ThermalThrottling::throttlingReleaseUpdate( - std::string_view sensor_name, - const std::unordered_map<std::string, CdevInfo> &cooling_device_info_map, - const std::unordered_map<std::string, PowerStatus> &power_status_map, - const ThrottlingSeverity severity, const SensorInfo &sensor_info) { - ATRACE_CALL(); - std::unique_lock<std::shared_mutex> _lock(thermal_throttling_status_map_mutex_); - if (!thermal_throttling_status_map_.count(sensor_name.data())) { - return false; - } - auto &thermal_throttling_status = thermal_throttling_status_map_.at(sensor_name.data()); - for (const auto &binded_cdev_info_pair : sensor_info.throttling_info->binded_cdev_info_map) { - float avg_power = -1; - - if (!thermal_throttling_status.throttling_release_map.count(binded_cdev_info_pair.first) || - !power_status_map.count(binded_cdev_info_pair.second.power_rail)) { - return false; - } - - const auto max_state = cooling_device_info_map.at(binded_cdev_info_pair.first).max_state; - - auto &release_step = - thermal_throttling_status.throttling_release_map.at(binded_cdev_info_pair.first); - avg_power = - power_status_map.at(binded_cdev_info_pair.second.power_rail).last_updated_avg_power; - - // Return false if we cannot get the AVG power - if (std::isnan(avg_power) || avg_power < 0) { - release_step = binded_cdev_info_pair.second.throttling_with_power_link ? max_state : 0; - continue; - } - - bool is_over_budget = true; - if (!binded_cdev_info_pair.second.high_power_check) { - if (avg_power < - binded_cdev_info_pair.second.power_thresholds[static_cast<int>(severity)]) { - is_over_budget = false; - } - } else { - if (avg_power > - binded_cdev_info_pair.second.power_thresholds[static_cast<int>(severity)]) { - is_over_budget = false; - } - } - LOG(INFO) << sensor_name.data() << "'s " << binded_cdev_info_pair.first - << " binded power rail " << binded_cdev_info_pair.second.power_rail - << ": power threshold = " - << binded_cdev_info_pair.second.power_thresholds[static_cast<int>(severity)] - << ", avg power = " << avg_power; - - switch (binded_cdev_info_pair.second.release_logic) { - case ReleaseLogic::INCREASE: - if (!is_over_budget) { - if (std::abs(release_step) < static_cast<int>(max_state)) { - release_step--; - } - } else { - release_step = 0; - } - break; - case ReleaseLogic::DECREASE: - if (!is_over_budget) { - if (release_step < static_cast<int>(max_state)) { - release_step++; - } - } else { - release_step = 0; - } - break; - case ReleaseLogic::STEPWISE: - if (!is_over_budget) { - if (release_step < static_cast<int>(max_state)) { - release_step++; - } - } else { - if (std::abs(release_step) < static_cast<int>(max_state)) { - release_step--; - } - } - break; - case ReleaseLogic::RELEASE_TO_FLOOR: - release_step = is_over_budget ? 0 : max_state; - break; - case ReleaseLogic::NONE: - default: - break; - } - } - return true; -} - -void ThermalThrottling::thermalThrottlingUpdate( - const Temperature_2_0 &temp, const SensorInfo &sensor_info, - const ThrottlingSeverity curr_severity, const std::chrono::milliseconds time_elapsed_ms, - const std::unordered_map<std::string, PowerStatus> &power_status_map, - const std::unordered_map<std::string, CdevInfo> &cooling_device_info_map) { - if (!thermal_throttling_status_map_.count(temp.name)) { - return; - } - - if (thermal_throttling_status_map_[temp.name].pid_power_budget_map.size()) { - updateCdevRequestByPower(temp, sensor_info, curr_severity, time_elapsed_ms, - cooling_device_info_map); - } - - if (thermal_throttling_status_map_[temp.name].hardlimit_cdev_request_map.size()) { - updateCdevRequestBySeverity(temp.name.c_str(), sensor_info, curr_severity); - } - - if (thermal_throttling_status_map_[temp.name].throttling_release_map.size()) { - throttlingReleaseUpdate(temp.name.c_str(), cooling_device_info_map, power_status_map, - curr_severity, sensor_info); - } -} - -void ThermalThrottling::computeCoolingDevicesRequest( - std::string_view sensor_name, const SensorInfo &sensor_info, - const ThrottlingSeverity curr_severity, - std::vector<std::string> *cooling_devices_to_update) { - int release_step = 0; - std::unique_lock<std::shared_mutex> _lock(thermal_throttling_status_map_mutex_); - - if (!thermal_throttling_status_map_.count(sensor_name.data())) { - return; - } - - auto &thermal_throttling_status = thermal_throttling_status_map_.at(sensor_name.data()); - const auto &cdev_release_map = thermal_throttling_status.throttling_release_map; - - for (auto &cdev_request_pair : thermal_throttling_status.cdev_status_map) { - int pid_cdev_request = 0; - int hardlimit_cdev_request = 0; - const auto &binded_cdev_info = - sensor_info.throttling_info->binded_cdev_info_map.at(cdev_request_pair.first); - const auto cdev_ceiling = binded_cdev_info.cdev_ceiling[static_cast<size_t>(curr_severity)]; - const auto cdev_floor = - binded_cdev_info.cdev_floor_with_power_link[static_cast<size_t>(curr_severity)]; - release_step = 0; - - if (thermal_throttling_status.pid_cdev_request_map.count(cdev_request_pair.first)) { - pid_cdev_request = - thermal_throttling_status.pid_cdev_request_map.at(cdev_request_pair.first); - } - - if (thermal_throttling_status.hardlimit_cdev_request_map.count(cdev_request_pair.first)) { - hardlimit_cdev_request = thermal_throttling_status.hardlimit_cdev_request_map.at( - cdev_request_pair.first); - } - - if (cdev_release_map.count(cdev_request_pair.first)) { - release_step = cdev_release_map.at(cdev_request_pair.first); - } - - LOG(VERBOSE) << sensor_name.data() << " binded cooling device " << cdev_request_pair.first - << "'s pid_request=" << pid_cdev_request - << " hardlimit_cdev_request=" << hardlimit_cdev_request - << " release_step=" << release_step - << " cdev_floor_with_power_link=" << cdev_floor - << " cdev_ceiling=" << cdev_ceiling; - - auto request_state = std::max(pid_cdev_request, hardlimit_cdev_request); - if (release_step) { - if (release_step >= request_state) { - request_state = 0; - } else { - request_state = request_state - release_step; - } - // Only check the cdev_floor when release step is non zero - if (request_state < cdev_floor) { - request_state = cdev_floor; - } - } - if (request_state > cdev_ceiling) { - request_state = cdev_ceiling; - } - - if (cdev_request_pair.second != request_state) { - cdev_request_pair.second = request_state; - cooling_devices_to_update->emplace_back(cdev_request_pair.first); - } - } -} - -} // namespace implementation -} // namespace V2_0 -} // namespace thermal -} // namespace hardware -} // namespace android diff --git a/thermal/pid_1_0/utils/thermal_throttling.h b/thermal/pid_1_0/utils/thermal_throttling.h deleted file mode 100644 index 63146465..00000000 --- a/thermal/pid_1_0/utils/thermal_throttling.h +++ /dev/null @@ -1,121 +0,0 @@ -/* - * Copyright (C) 2022 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. - */ - -#pragma once - -#include <android/hardware/thermal/2.0/IThermal.h> - -#include <queue> -#include <shared_mutex> -#include <string> -#include <unordered_map> -#include <unordered_set> - -#include "power_files.h" -#include "thermal_info.h" - -namespace android { -namespace hardware { -namespace thermal { -namespace V2_0 { -namespace implementation { - -using ::android::hardware::hidl_vec; -using ::android::hardware::thermal::V2_0::IThermal; -using Temperature_2_0 = ::android::hardware::thermal::V2_0::Temperature; -using ::android::hardware::thermal::V2_0::TemperatureThreshold; -using ::android::hardware::thermal::V2_0::ThrottlingSeverity; - -struct ThermalThrottlingStatus { - std::unordered_map<std::string, int> pid_power_budget_map; - std::unordered_map<std::string, int> pid_cdev_request_map; - std::unordered_map<std::string, int> hardlimit_cdev_request_map; - std::unordered_map<std::string, int> throttling_release_map; - std::unordered_map<std::string, int> cdev_status_map; - float err_integral; - float prev_err; -}; - -// Return the target state of PID algorithm -size_t getTargetStateOfPID(const SensorInfo &sensor_info, const ThrottlingSeverity curr_severity); - -// A helper class for conducting thermal throttling -class ThermalThrottling { - public: - ThermalThrottling() = default; - ~ThermalThrottling() = default; - // Disallow copy and assign. - ThermalThrottling(const ThermalThrottling &) = delete; - void operator=(const ThermalThrottling &) = delete; - - // Clear throttling data - void clearThrottlingData(std::string_view sensor_name, const SensorInfo &sensor_info); - // Register map for throttling algo - bool registerThermalThrottling( - std::string_view sensor_name, const std::shared_ptr<ThrottlingInfo> &throttling_info, - const std::unordered_map<std::string, CdevInfo> &cooling_device_info_map); - // Register map for throttling release algo - bool registerThrottlingReleaseToWatch(std::string_view sensor_name, std::string_view cdev_name, - const BindedCdevInfo &binded_cdev_info); - // Get throttling status map - const std::unordered_map<std::string, ThermalThrottlingStatus> &GetThermalThrottlingStatusMap() - const { - std::shared_lock<std::shared_mutex> _lock(thermal_throttling_status_map_mutex_); - return thermal_throttling_status_map_; - } - // update thermal throttling request for the specific sensor - void thermalThrottlingUpdate( - const Temperature_2_0 &temp, const SensorInfo &sensor_info, - const ThrottlingSeverity curr_severity, const std::chrono::milliseconds time_elapsed_ms, - const std::unordered_map<std::string, PowerStatus> &power_status_map, - const std::unordered_map<std::string, CdevInfo> &cooling_device_info_map); - - // Compute the throttling target from all the sensors' request - void computeCoolingDevicesRequest(std::string_view sensor_name, const SensorInfo &sensor_info, - const ThrottlingSeverity curr_severity, - std::vector<std::string> *cooling_devices_to_update); - - private: - // PID algo - get the total power budget - float updatePowerBudget(const Temperature_2_0 &temp, const SensorInfo &sensor_info, - std::chrono::milliseconds time_elapsed_ms, - ThrottlingSeverity curr_severity); - // PID algo - map the target throttling state according to the power budget - bool updateCdevRequestByPower( - const Temperature_2_0 &temp, const SensorInfo &sensor_info, - const ThrottlingSeverity curr_severity, const std::chrono::milliseconds time_elapsed_ms, - const std::unordered_map<std::string, CdevInfo> &cooling_device_info_map); - // Hard limit algo - assign the throttling state according to the severity - void updateCdevRequestBySeverity(std::string_view sensor_name, const SensorInfo &sensor_info, - ThrottlingSeverity curr_severity); - // Throttling release algo according to predefined power threshold - bool throttlingReleaseUpdate( - std::string_view sensor_name, - const std::unordered_map<std::string, CdevInfo> &cooling_device_info_map, - const std::unordered_map<std::string, PowerStatus> &power_status_map, - const ThrottlingSeverity severity, const SensorInfo &sensor_info); - - mutable std::shared_mutex thermal_throttling_status_map_mutex_; - // Thermal throttling status from each sensor - std::unordered_map<std::string, ThermalThrottlingStatus> thermal_throttling_status_map_; - std::vector<std::string> cooling_devices_to_update; -}; - -} // namespace implementation -} // namespace V2_0 -} // namespace thermal -} // namespace hardware -} // namespace android diff --git a/thermal/pid_1_0/utils/thermal_watcher.cpp b/thermal/pid_1_0/utils/thermal_watcher.cpp deleted file mode 100644 index 7ff1d898..00000000 --- a/thermal/pid_1_0/utils/thermal_watcher.cpp +++ /dev/null @@ -1,535 +0,0 @@ -/* - * Copyright (C) 2018 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 ATRACE_TAG (ATRACE_TAG_THERMAL | ATRACE_TAG_HAL) - -#include "thermal_watcher.h" - -#include <android-base/file.h> -#include <android-base/logging.h> -#include <android-base/stringprintf.h> -#include <android-base/strings.h> -#include <cutils/uevent.h> -#include <dirent.h> -#include <linux/netlink.h> -#include <linux/thermal.h> -#include <sys/inotify.h> -#include <sys/resource.h> -#include <sys/types.h> -#include <utils/Trace.h> - -#include <chrono> -#include <fstream> - -#include "../thermal-helper.h" - -namespace android { -namespace hardware { -namespace thermal { -namespace V2_0 { -namespace implementation { - -namespace { - -static int nlErrorHandle(struct sockaddr_nl *nla, struct nlmsgerr *err, void *arg) { - int *ret = reinterpret_cast<int *>(arg); - *ret = err->error; - LOG(ERROR) << __func__ << "nl_groups: " << nla->nl_groups << ", nl_pid: " << nla->nl_pid; - - return NL_STOP; -} - -static int nlFinishHandle(struct nl_msg *msg, void *arg) { - int *ret = reinterpret_cast<int *>(arg); - *ret = 1; - struct nlmsghdr *nlh = nlmsg_hdr(msg); - - LOG(VERBOSE) << __func__ << ": nlmsg type: " << nlh->nlmsg_type; - - return NL_OK; -} - -static int nlAckHandle(struct nl_msg *msg, void *arg) { - int *ret = reinterpret_cast<int *>(arg); - *ret = 1; - struct nlmsghdr *nlh = nlmsg_hdr(msg); - - LOG(VERBOSE) << __func__ << ": nlmsg type: " << nlh->nlmsg_type; - - return NL_OK; -} - -static int nlSeqCheckHandle(struct nl_msg *msg, void *arg) { - int *ret = reinterpret_cast<int *>(arg); - *ret = 1; - struct nlmsghdr *nlh = nlmsg_hdr(msg); - - LOG(VERBOSE) << __func__ << ": nlmsg type: " << nlh->nlmsg_type; - - return NL_OK; -} - -struct HandlerArgs { - const char *group; - int id; -}; - -static int nlSendMsg(struct nl_sock *sock, struct nl_msg *msg, - int (*rx_handler)(struct nl_msg *, void *), void *data) { - int err, done = 0; - - std::unique_ptr<nl_cb, decltype(&nl_cb_put)> cb(nl_cb_alloc(NL_CB_DEFAULT), nl_cb_put); - - err = nl_send_auto_complete(sock, msg); - if (err < 0) - return err; - - err = 0; - nl_cb_err(cb.get(), NL_CB_CUSTOM, nlErrorHandle, &err); - nl_cb_set(cb.get(), NL_CB_FINISH, NL_CB_CUSTOM, nlFinishHandle, &done); - nl_cb_set(cb.get(), NL_CB_ACK, NL_CB_CUSTOM, nlAckHandle, &done); - - if (rx_handler != NULL) - nl_cb_set(cb.get(), NL_CB_VALID, NL_CB_CUSTOM, rx_handler, data); - - while (err == 0 && done == 0) nl_recvmsgs(sock, cb.get()); - - return err; -} - -static int nlFamilyHandle(struct nl_msg *msg, void *arg) { - struct HandlerArgs *grp = reinterpret_cast<struct HandlerArgs *>(arg); - struct nlattr *tb[CTRL_ATTR_MAX + 1]; - struct genlmsghdr *gnlh = (struct genlmsghdr *)nlmsg_data(nlmsg_hdr(msg)); - struct nlattr *mcgrp; - int rem_mcgrp; - - nla_parse(tb, CTRL_ATTR_MAX, genlmsg_attrdata(gnlh, 0), genlmsg_attrlen(gnlh, 0), NULL); - - if (!tb[CTRL_ATTR_MCAST_GROUPS]) { - LOG(ERROR) << __func__ << "Multicast group not found"; - return -1; - } - - nla_for_each_nested(mcgrp, tb[CTRL_ATTR_MCAST_GROUPS], rem_mcgrp) { - struct nlattr *tb_mcgrp[CTRL_ATTR_MCAST_GRP_MAX + 1]; - - nla_parse(tb_mcgrp, CTRL_ATTR_MCAST_GRP_MAX, reinterpret_cast<nlattr *>(nla_data(mcgrp)), - nla_len(mcgrp), NULL); - - if (!tb_mcgrp[CTRL_ATTR_MCAST_GRP_NAME] || !tb_mcgrp[CTRL_ATTR_MCAST_GRP_ID]) - continue; - - if (strncmp(reinterpret_cast<char *>(nla_data(tb_mcgrp[CTRL_ATTR_MCAST_GRP_NAME])), - grp->group, nla_len(tb_mcgrp[CTRL_ATTR_MCAST_GRP_NAME])) != 0) - continue; - - grp->id = nla_get_u32(tb_mcgrp[CTRL_ATTR_MCAST_GRP_ID]); - - break; - } - - return 0; -} - -static int nlGetMulticastId(struct nl_sock *sock, const char *family, const char *group) { - int err = 0, ctrlid; - struct HandlerArgs grp = { - .group = group, - .id = -ENOENT, - }; - - std::unique_ptr<nl_msg, decltype(&nlmsg_free)> msg(nlmsg_alloc(), nlmsg_free); - - ctrlid = genl_ctrl_resolve(sock, "nlctrl"); - - genlmsg_put(msg.get(), 0, 0, ctrlid, 0, 0, CTRL_CMD_GETFAMILY, 0); - - nla_put_string(msg.get(), CTRL_ATTR_FAMILY_NAME, family); - - err = nlSendMsg(sock, msg.get(), nlFamilyHandle, &grp); - if (err) - return err; - - err = grp.id; - LOG(INFO) << group << " multicast_id: " << grp.id; - - return err; -} - -static bool socketAddMembership(struct nl_sock *sock, const char *group) { - int mcid = nlGetMulticastId(sock, THERMAL_GENL_FAMILY_NAME, group); - if (mcid < 0) { - LOG(ERROR) << "Failed to get multicast id: " << group; - return false; - } - - if (nl_socket_add_membership(sock, mcid)) { - LOG(ERROR) << "Failed to add netlink socket membership: " << group; - return false; - } - - LOG(INFO) << "Added netlink socket membership: " << group; - return true; -} - -static int handleEvent(struct nl_msg *n, void *arg) { - struct nlmsghdr *nlh = nlmsg_hdr(n); - struct genlmsghdr *glh = genlmsg_hdr(nlh); - struct nlattr *attrs[THERMAL_GENL_ATTR_MAX + 1]; - int *tz_id = reinterpret_cast<int *>(arg); - - genlmsg_parse(nlh, 0, attrs, THERMAL_GENL_ATTR_MAX, NULL); - - if (glh->cmd == THERMAL_GENL_EVENT_TZ_TRIP_UP) { - LOG(INFO) << "THERMAL_GENL_EVENT_TZ_TRIP_UP"; - if (attrs[THERMAL_GENL_ATTR_TZ_ID]) { - LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]); - *tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]); - } - if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID]) - LOG(INFO) << "Thermal zone trip id: " - << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID]); - } - - if (glh->cmd == THERMAL_GENL_EVENT_TZ_TRIP_DOWN) { - LOG(INFO) << "THERMAL_GENL_EVENT_TZ_TRIP_DOWN"; - if (attrs[THERMAL_GENL_ATTR_TZ_ID]) { - LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]); - *tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]); - } - if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID]) - LOG(INFO) << "Thermal zone trip id: " - << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID]); - } - - if (glh->cmd == THERMAL_GENL_EVENT_TZ_GOV_CHANGE) { - LOG(INFO) << "THERMAL_GENL_EVENT_TZ_GOV_CHANGE"; - if (attrs[THERMAL_GENL_ATTR_TZ_ID]) { - LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]); - *tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]); - } - if (attrs[THERMAL_GENL_ATTR_GOV_NAME]) - LOG(INFO) << "Governor name: " << nla_get_string(attrs[THERMAL_GENL_ATTR_GOV_NAME]); - } - - if (glh->cmd == THERMAL_GENL_EVENT_TZ_CREATE) { - LOG(INFO) << "THERMAL_GENL_EVENT_TZ_CREATE"; - if (attrs[THERMAL_GENL_ATTR_TZ_ID]) { - LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]); - *tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]); - } - if (attrs[THERMAL_GENL_ATTR_TZ_NAME]) - LOG(INFO) << "Thermal zone name: " << nla_get_string(attrs[THERMAL_GENL_ATTR_TZ_NAME]); - } - - if (glh->cmd == THERMAL_GENL_EVENT_TZ_DELETE) { - LOG(INFO) << "THERMAL_GENL_EVENT_TZ_DELETE"; - if (attrs[THERMAL_GENL_ATTR_TZ_ID]) { - LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]); - *tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]); - } - } - - if (glh->cmd == THERMAL_GENL_EVENT_TZ_DISABLE) { - LOG(INFO) << "THERMAL_GENL_EVENT_TZ_DISABLE"; - if (attrs[THERMAL_GENL_ATTR_TZ_ID]) { - LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]); - *tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]); - } - } - - if (glh->cmd == THERMAL_GENL_EVENT_TZ_ENABLE) { - LOG(INFO) << "THERMAL_GENL_EVENT_TZ_ENABLE"; - if (attrs[THERMAL_GENL_ATTR_TZ_ID]) { - LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]); - *tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]); - } - } - - if (glh->cmd == THERMAL_GENL_EVENT_TZ_TRIP_CHANGE) { - LOG(INFO) << "THERMAL_GENL_EVENT_TZ_TRIP_CHANGE"; - if (attrs[THERMAL_GENL_ATTR_TZ_ID]) { - LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]); - *tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]); - } - if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID]) - LOG(INFO) << "Trip id:: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID]); - if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_TYPE]) - LOG(INFO) << "Trip type: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_TYPE]); - if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_TEMP]) - LOG(INFO) << "Trip temp: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_TEMP]); - if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_HYST]) - LOG(INFO) << "Trip hyst: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_HYST]); - } - - if (glh->cmd == THERMAL_GENL_EVENT_TZ_TRIP_ADD) { - LOG(INFO) << "THERMAL_GENL_EVENT_TZ_TRIP_ADD"; - if (attrs[THERMAL_GENL_ATTR_TZ_ID]) - LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]); - if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID]) - LOG(INFO) << "Trip id:: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID]); - if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_TYPE]) - LOG(INFO) << "Trip type: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_TYPE]); - if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_TEMP]) - LOG(INFO) << "Trip temp: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_TEMP]); - if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_HYST]) - LOG(INFO) << "Trip hyst: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_HYST]); - } - - if (glh->cmd == THERMAL_GENL_EVENT_TZ_TRIP_DELETE) { - LOG(INFO) << "THERMAL_GENL_EVENT_TZ_TRIP_DELETE"; - if (attrs[THERMAL_GENL_ATTR_TZ_ID]) { - LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]); - *tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]); - } - if (attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID]) - LOG(INFO) << "Trip id:: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TRIP_ID]); - } - - if (glh->cmd == THERMAL_GENL_EVENT_CDEV_STATE_UPDATE) { - LOG(INFO) << "THERMAL_GENL_EVENT_CDEV_STATE_UPDATE"; - if (attrs[THERMAL_GENL_ATTR_CDEV_ID]) - LOG(INFO) << "Cooling device id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_CDEV_ID]); - if (attrs[THERMAL_GENL_ATTR_CDEV_CUR_STATE]) - LOG(INFO) << "Cooling device current state: " - << nla_get_u32(attrs[THERMAL_GENL_ATTR_CDEV_CUR_STATE]); - } - - if (glh->cmd == THERMAL_GENL_EVENT_CDEV_ADD) { - LOG(INFO) << "THERMAL_GENL_EVENT_CDEV_ADD"; - if (attrs[THERMAL_GENL_ATTR_CDEV_NAME]) - LOG(INFO) << "Cooling device name: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_CDEV_NAME]); - if (attrs[THERMAL_GENL_ATTR_CDEV_ID]) - LOG(INFO) << "Cooling device id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_CDEV_ID]); - if (attrs[THERMAL_GENL_ATTR_CDEV_MAX_STATE]) - LOG(INFO) << "Cooling device max state: " - << nla_get_u32(attrs[THERMAL_GENL_ATTR_CDEV_MAX_STATE]); - } - - if (glh->cmd == THERMAL_GENL_EVENT_CDEV_DELETE) { - LOG(INFO) << "THERMAL_GENL_EVENT_CDEV_DELETE"; - if (attrs[THERMAL_GENL_ATTR_CDEV_ID]) - LOG(INFO) << "Cooling device id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_CDEV_ID]); - } - - if (glh->cmd == THERMAL_GENL_SAMPLING_TEMP) { - LOG(INFO) << "THERMAL_GENL_SAMPLING_TEMP"; - if (attrs[THERMAL_GENL_ATTR_TZ_ID]) { - LOG(INFO) << "Thermal zone id: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]); - *tz_id = nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_ID]); - } - if (attrs[THERMAL_GENL_ATTR_TZ_TEMP]) - LOG(INFO) << "Thermal zone temp: " << nla_get_u32(attrs[THERMAL_GENL_ATTR_TZ_TEMP]); - } - - return 0; -} - -} // namespace - -void ThermalWatcher::registerFilesToWatch(const std::set<std::string> &sensors_to_watch) { - LOG(INFO) << "Uevent register file to watch..."; - monitored_sensors_.insert(sensors_to_watch.begin(), sensors_to_watch.end()); - - uevent_fd_.reset((TEMP_FAILURE_RETRY(uevent_open_socket(64 * 1024, true)))); - if (uevent_fd_.get() < 0) { - LOG(ERROR) << "failed to open uevent socket"; - return; - } - - fcntl(uevent_fd_, F_SETFL, O_NONBLOCK); - - looper_->addFd(uevent_fd_.get(), 0, Looper::EVENT_INPUT, nullptr, nullptr); - sleep_ms_ = std::chrono::milliseconds(0); - last_update_time_ = boot_clock::now(); -} - -void ThermalWatcher::registerFilesToWatchNl(const std::set<std::string> &sensors_to_watch) { - LOG(INFO) << "Thermal genl register file to watch..."; - monitored_sensors_.insert(sensors_to_watch.begin(), sensors_to_watch.end()); - - sk_thermal = nl_socket_alloc(); - if (!sk_thermal) { - LOG(ERROR) << "nl_socket_alloc failed"; - return; - } - - if (genl_connect(sk_thermal)) { - LOG(ERROR) << "genl_connect failed: sk_thermal"; - return; - } - - thermal_genl_fd_.reset(nl_socket_get_fd(sk_thermal)); - if (thermal_genl_fd_.get() < 0) { - LOG(ERROR) << "Failed to create thermal netlink socket"; - return; - } - - if (!socketAddMembership(sk_thermal, THERMAL_GENL_EVENT_GROUP_NAME)) { - return; - } - - /* - * Currently, only the update_temperature() will send thermal genl samlping events - * from kernel. To avoid thermal-hal busy because samlping events are sent - * too frequently, ignore thermal genl samlping events until we figure out how to use it. - * - if (!socketAddMembership(sk_thermal, THERMAL_GENL_SAMPLING_GROUP_NAME)) { - return; - } - */ - - fcntl(thermal_genl_fd_, F_SETFL, O_NONBLOCK); - looper_->addFd(thermal_genl_fd_.get(), 0, Looper::EVENT_INPUT, nullptr, nullptr); - sleep_ms_ = std::chrono::milliseconds(0); - last_update_time_ = boot_clock::now(); -} - -bool ThermalWatcher::startWatchingDeviceFiles() { - if (cb_) { - auto ret = this->run("FileWatcherThread", PRIORITY_HIGHEST); - if (ret != NO_ERROR) { - LOG(ERROR) << "ThermalWatcherThread start fail"; - return false; - } else { - LOG(INFO) << "ThermalWatcherThread started"; - return true; - } - } - return false; -} -void ThermalWatcher::parseUevent(std::set<std::string> *sensors_set) { - bool thermal_event = false; - constexpr int kUeventMsgLen = 2048; - char msg[kUeventMsgLen + 2]; - char *cp; - - while (true) { - int n = uevent_kernel_multicast_recv(uevent_fd_.get(), msg, kUeventMsgLen); - if (n <= 0) { - if (errno != EAGAIN && errno != EWOULDBLOCK) { - LOG(ERROR) << "Error reading from Uevent Fd"; - } - break; - } - - if (n >= kUeventMsgLen) { - LOG(ERROR) << "Uevent overflowed buffer, discarding"; - continue; - } - - msg[n] = '\0'; - msg[n + 1] = '\0'; - - cp = msg; - while (*cp) { - std::string uevent = cp; - auto findSubSystemThermal = uevent.find("SUBSYSTEM=thermal"); - if (!thermal_event) { - if (!uevent.find("SUBSYSTEM=")) { - if (findSubSystemThermal != std::string::npos) { - thermal_event = true; - } else { - break; - } - } - } else { - auto start_pos = uevent.find("NAME="); - if (start_pos != std::string::npos) { - start_pos += 5; - std::string name = uevent.substr(start_pos); - if (std::find(monitored_sensors_.begin(), monitored_sensors_.end(), name) != - monitored_sensors_.end()) { - sensors_set->insert(name); - } - break; - } - } - while (*cp++) { - } - } - } -} - -// TODO(b/175367921): Consider for potentially adding more type of event in the function -// instead of just add the sensors to the list. -void ThermalWatcher::parseGenlink(std::set<std::string> *sensors_set) { - int err = 0, done = 0, tz_id = -1; - - std::unique_ptr<nl_cb, decltype(&nl_cb_put)> cb(nl_cb_alloc(NL_CB_DEFAULT), nl_cb_put); - - nl_cb_err(cb.get(), NL_CB_CUSTOM, nlErrorHandle, &err); - nl_cb_set(cb.get(), NL_CB_FINISH, NL_CB_CUSTOM, nlFinishHandle, &done); - nl_cb_set(cb.get(), NL_CB_ACK, NL_CB_CUSTOM, nlAckHandle, &done); - nl_cb_set(cb.get(), NL_CB_SEQ_CHECK, NL_CB_CUSTOM, nlSeqCheckHandle, &done); - nl_cb_set(cb.get(), NL_CB_VALID, NL_CB_CUSTOM, handleEvent, &tz_id); - - while (!done && !err) { - nl_recvmsgs(sk_thermal, cb.get()); - - if (tz_id < 0) { - break; - } - - std::string name; - if (getThermalZoneTypeById(tz_id, &name) && - std::find(monitored_sensors_.begin(), monitored_sensors_.end(), name) != - monitored_sensors_.end()) { - sensors_set->insert(name); - } - } -} - -void ThermalWatcher::wake() { - looper_->wake(); -} - -bool ThermalWatcher::threadLoop() { - LOG(VERBOSE) << "ThermalWatcher polling..."; - - int fd; - std::set<std::string> sensors; - - auto time_elapsed_ms = std::chrono::duration_cast<std::chrono::milliseconds>(boot_clock::now() - - last_update_time_); - - if (time_elapsed_ms < sleep_ms_ && - looper_->pollOnce(sleep_ms_.count(), &fd, nullptr, nullptr) >= 0) { - ATRACE_NAME("ThermalWatcher::threadLoop - receive event"); - if (fd != uevent_fd_.get() && fd != thermal_genl_fd_.get()) { - return true; - } else if (fd == thermal_genl_fd_.get()) { - parseGenlink(&sensors); - } else if (fd == uevent_fd_.get()) { - parseUevent(&sensors); - } - // Ignore cb_ if uevent is not from monitored sensors - if (sensors.size() == 0) { - return true; - } - } - - sleep_ms_ = cb_(sensors); - last_update_time_ = boot_clock::now(); - return true; -} - -} // namespace implementation -} // namespace V2_0 -} // namespace thermal -} // namespace hardware -} // namespace android diff --git a/thermal/pid_1_0/utils/thermal_watcher.h b/thermal/pid_1_0/utils/thermal_watcher.h deleted file mode 100644 index a7e3820f..00000000 --- a/thermal/pid_1_0/utils/thermal_watcher.h +++ /dev/null @@ -1,114 +0,0 @@ -/* - * Copyright (C) 2018 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. - */ - -#pragma once - -#include <android-base/chrono_utils.h> -#include <android-base/unique_fd.h> -#include <linux/genetlink.h> -#include <netlink/genl/ctrl.h> -#include <netlink/genl/genl.h> -#include <utils/Looper.h> -#include <utils/Thread.h> - -#include <chrono> -#include <condition_variable> -#include <future> -#include <list> -#include <mutex> -#include <set> -#include <string> -#include <thread> -#include <unordered_map> -#include <vector> - -namespace android { -namespace hardware { -namespace thermal { -namespace V2_0 { -namespace implementation { - -using android::base::boot_clock; -using android::base::unique_fd; -using WatcherCallback = std::function<std::chrono::milliseconds(const std::set<std::string> &name)>; - -// A helper class for monitoring thermal files changes. -class ThermalWatcher : public ::android::Thread { - public: - explicit ThermalWatcher(const WatcherCallback &cb) - : Thread(false), cb_(cb), looper_(new Looper(true)) {} - ~ThermalWatcher() = default; - - // Disallow copy and assign. - ThermalWatcher(const ThermalWatcher &) = delete; - void operator=(const ThermalWatcher &) = delete; - - // Start the thread and return true if it succeeds. - bool startWatchingDeviceFiles(); - // Give the file watcher a list of files to start watching. This helper - // class will by default wait for modifications to the file with a looper. - // This should be called before starting watcher thread. - // For monitoring uevents. - void registerFilesToWatch(const std::set<std::string> &sensors_to_watch); - // For monitoring thermal genl events. - void registerFilesToWatchNl(const std::set<std::string> &sensors_to_watch); - // Wake up the looper thus the worker thread, immediately. This can be called - // in any thread. - void wake(); - - private: - // The work done by the watcher thread. This will use inotify to check for - // modifications to the files to watch. If any modification is seen this - // will callback the registered function with the new data read from the - // modified file. - bool threadLoop() override; - - // Parse uevent message - void parseUevent(std::set<std::string> *sensor_name); - - // Parse thermal netlink message - void parseGenlink(std::set<std::string> *sensor_name); - - // Maps watcher filer descriptor to watched file path. - std::unordered_map<int, std::string> watch_to_file_path_map_; - - // The callback function. Called whenever thermal uevent is seen. - // The function passed in should expect a string in the form (type). - // Where type is the name of the thermal zone that trigger a uevent notification. - // Callback will return thermal trigger status for next polling decision. - const WatcherCallback cb_; - - sp<Looper> looper_; - - // For uevent socket registration. - android::base::unique_fd uevent_fd_; - // For thermal genl socket registration. - android::base::unique_fd thermal_genl_fd_; - // Sensor list which monitor flag is enabled. - std::set<std::string> monitored_sensors_; - // Sleep interval voting result - std::chrono::milliseconds sleep_ms_; - // Timestamp for last thermal update - boot_clock::time_point last_update_time_; - // For thermal genl socket object. - struct nl_sock *sk_thermal; -}; - -} // namespace implementation -} // namespace V2_0 -} // namespace thermal -} // namespace hardware -} // namespace android diff --git a/thermal/pixel-thermal-logd.rc b/thermal/pixel-thermal-logd.rc index 9345171c..c2ec9ff8 100644 --- a/thermal/pixel-thermal-logd.rc +++ b/thermal/pixel-thermal-logd.rc @@ -17,16 +17,22 @@ service vendor.thermal.logd /vendor/bin/thermal_logd ${persist.vendor.log.therma on property:persist.vendor.disable.thermal.control=* setprop vendor.disable.thermal.control ${persist.vendor.disable.thermal.control} +on property:persist.vendor.disable.thermalhal.control=* + setprop vendor.disable.thermalhal.control ${persist.vendor.disable.thermalhal.control} + on property:persist.vendor.disable.usb.overheat.mitigation=* setprop vendor.disable.usb.overheat.mitigation.control ${persist.vendor.disable.usb.overheat.mitigation} on property:persist.vendor.disable.bcl.control=* setprop vendor.disable.bcl.control ${persist.vendor.disable.bcl.control} +on property:vendor.disable.thermalhal.control=* && property:vendor.thermal.link_ready=1 + restart vendor.thermal-hal + on property:vendor.disable.thermal.control=1 && property:vendor.thermal.link_ready=1 # common stop vendor.thermal-engine - restart vendor.thermal-hal-2-0 + setprop vendor.disable.thermalhal.control 1 # sdm845 write /dev/thermal/tz-by-name/quiet-therm-adc/mode disabled write /dev/thermal/tz-by-name/quiet-therm-monitor/mode disabled @@ -68,7 +74,7 @@ on property:vendor.disable.thermal.control=1 && property:vendor.thermal.link_rea on property:vendor.disable.thermal.control=0 && property:vendor.thermal.link_ready=1 # common start vendor.thermal-engine - restart vendor.thermal-hal-2-0 + setprop vendor.disable.thermalhal.control 0 # sdm845 write /dev/thermal/tz-by-name/quiet-therm-adc/mode enabled write /dev/thermal/tz-by-name/quiet-therm-monitor/mode enabled diff --git a/thermal/pixel-thermal-symlinks.rc b/thermal/pixel-thermal-symlinks.rc index a1f65094..132ec5fe 100644 --- a/thermal/pixel-thermal-symlinks.rc +++ b/thermal/pixel-thermal-symlinks.rc @@ -1,11 +1,11 @@ -on early-boot +on boot mkdir /dev/thermal 0750 system system mkdir /dev/thermal/tz-by-name 0750 system system mkdir /dev/thermal/cdev-by-name 0750 system system start vendor.thermal.symlinks service vendor.thermal.symlinks /vendor/bin/thermal_symlinks - class hal user system group system oneshot + disabled diff --git a/thermal/service.cpp b/thermal/service.cpp index 28d262ad..d18a0693 100644 --- a/thermal/service.cpp +++ b/thermal/service.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2018 The Android Open Source Project + * Copyright (C) 2022 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. @@ -14,7 +14,9 @@ * limitations under the License. */ #include <android-base/logging.h> -#include <hidl/HidlTransportSupport.h> +#include <android/binder_manager.h> +#include <android/binder_process.h> + #include "Thermal.h" constexpr std::string_view kThermalLogTag("pixel-thermal"); @@ -22,44 +24,28 @@ constexpr std::string_view kThermalLogTag("pixel-thermal"); using ::android::OK; using ::android::status_t; -// libhwbinder: -using ::android::hardware::configureRpcThreadpool; -using ::android::hardware::joinRpcThreadpool; - -// Generated HIDL files: -using ::android::hardware::thermal::V2_0::IThermal; -using ::android::hardware::thermal::V2_0::implementation::Thermal; +// Generated AIDL files: +using Thermal = ::aidl::android::hardware::thermal::implementation::Thermal; -static int shutdown() { - LOG(ERROR) << "Pixel Thermal HAL Service is shutting down."; - return 1; -} +#if !defined(THERMAL_INSTANCE_NAME) +#define THERMAL_INSTANCE_NAME "default" +#endif int main(int /* argc */, char ** /* argv */) { android::base::SetDefaultTag(kThermalLogTag.data()); - status_t status; - android::sp<IThermal> service = nullptr; - - LOG(INFO) << "Pixel Thermal HAL Service 2.0 starting..."; - service = new Thermal(); - if (service == nullptr) { - LOG(ERROR) << "Error creating an instance of Thermal HAL. Exiting..."; - return shutdown(); - } - - configureRpcThreadpool(1, true /* callerWillJoin */); + auto svc = ndk::SharedRefBase::make<Thermal>(); + const auto svcName = std::string() + svc->descriptor + "/" + THERMAL_INSTANCE_NAME; + LOG(INFO) << "Pixel Thermal AIDL Service starting..." + svcName; + ABinderProcess_setThreadPoolMaxThreadCount(0); - android::hardware::setMinSchedulerPolicy(service, SCHED_NORMAL, -20); - - status = service->registerAsService(); - if (status != OK) { - LOG(ERROR) << "Could not register service for ThermalHAL (" << status << ")"; - return shutdown(); + auto svcBinder = svc->asBinder(); + binder_status_t status = AServiceManager_addService(svcBinder.get(), svcName.c_str()); + if (status != STATUS_OK) { + LOG(ERROR) << "Pixel Thermal AIDL Service failed to start: " << status << "."; + return EXIT_FAILURE; } - - LOG(INFO) << "Pixel Thermal HAL Service 2.0 started successfully."; - joinRpcThreadpool(); - // We should not get past the joinRpcThreadpool(). - return shutdown(); + LOG(INFO) << "Pixel Thermal HAL AIDL Service started."; + ABinderProcess_joinThreadPool(); + return EXIT_FAILURE; // should not reach } diff --git a/thermal/thermal-helper.cpp b/thermal/thermal-helper.cpp index 8bc67414..d7411bc3 100644 --- a/thermal/thermal-helper.cpp +++ b/thermal/thermal-helper.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2018 The Android Open Source Project + * Copyright (C) 2022 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. @@ -30,17 +30,13 @@ #include <thread> #include <vector> +namespace aidl { namespace android { namespace hardware { namespace thermal { -namespace V2_0 { namespace implementation { -constexpr std::string_view kCpuOnlineRoot("/sys/devices/system/cpu"); constexpr std::string_view kThermalSensorsRoot("/sys/devices/virtual/thermal"); -constexpr std::string_view kCpuUsageFile("/proc/stat"); -constexpr std::string_view kCpuOnlineFileSuffix("online"); -constexpr std::string_view kCpuPresentFile("/sys/devices/system/cpu/present"); constexpr std::string_view kSensorPrefix("thermal_zone"); constexpr std::string_view kCoolingDevicePrefix("cooling_device"); constexpr std::string_view kThermalNameFile("type"); @@ -55,88 +51,10 @@ constexpr std::string_view kCoolingDeviceState2powerSuffix("state2power_table"); constexpr std::string_view kConfigProperty("vendor.thermal.config"); constexpr std::string_view kConfigDefaultFileName("thermal_info_config.json"); constexpr std::string_view kThermalGenlProperty("persist.vendor.enable.thermal.genl"); -constexpr std::string_view kThermalDisabledProperty("vendor.disable.thermal.control"); +constexpr std::string_view kThermalDisabledProperty("vendor.disable.thermalhal.control"); namespace { -using android::base::StringPrintf; - -/* - * Pixel don't offline CPU, so std::thread::hardware_concurrency(); should work. - * However /sys/devices/system/cpu/present is preferred. - * The file is expected to contain single text line with two numbers %d-%d, - * which is a range of available cpu numbers, e.g. 0-7 would mean there - * are 8 cores number from 0 to 7. - * For Android systems this approach is safer than using cpufeatures, see bug - * b/36941727. - */ -static int getNumberOfCores() { - std::string file; - if (!android::base::ReadFileToString(kCpuPresentFile.data(), &file)) { - LOG(ERROR) << "Error reading CPU present file: " << kCpuPresentFile; - return 0; - } - std::vector<std::string> pieces = android::base::Split(file, "-"); - if (pieces.size() != 2) { - LOG(ERROR) << "Error parsing CPU present file content: " << file; - return 0; - } - auto min_core = std::stoul(pieces[0]); - auto max_core = std::stoul(pieces[1]); - if (max_core < min_core) { - LOG(ERROR) << "Error parsing CPU present min and max: " << min_core << " - " << max_core; - return 0; - } - return static_cast<std::size_t>(max_core - min_core + 1); -} -const int kMaxCpus = getNumberOfCores(); - -void parseCpuUsagesFileAndAssignUsages(hidl_vec<CpuUsage> *cpu_usages) { - std::string data; - if (!android::base::ReadFileToString(kCpuUsageFile.data(), &data)) { - LOG(ERROR) << "Error reading CPU usage file: " << kCpuUsageFile; - return; - } - - std::istringstream stat_data(data); - std::string line; - while (std::getline(stat_data, line)) { - if (!line.find("cpu") && isdigit(line[3])) { - // Split the string using spaces. - std::vector<std::string> words = android::base::Split(line, " "); - std::string cpu_name = words[0]; - int cpu_num = std::stoi(cpu_name.substr(3)); - - if (cpu_num < kMaxCpus) { - uint64_t user = std::stoull(words[1]); - uint64_t nice = std::stoull(words[2]); - uint64_t system = std::stoull(words[3]); - uint64_t idle = std::stoull(words[4]); - - // Check if the CPU is online by reading the online file. - std::string cpu_online_path = - StringPrintf("%s/%s/%s", kCpuOnlineRoot.data(), cpu_name.c_str(), - kCpuOnlineFileSuffix.data()); - std::string is_online; - if (!android::base::ReadFileToString(cpu_online_path, &is_online)) { - LOG(ERROR) << "Could not open CPU online file: " << cpu_online_path; - if (cpu_num != 0) { - return; - } - // Some architecture cannot offline cpu0, so assuming it is online - is_online = "1"; - } - is_online = android::base::Trim(is_online); - - (*cpu_usages)[cpu_num].active = user + nice + system; - (*cpu_usages)[cpu_num].total = user + nice + system + idle; - (*cpu_usages)[cpu_num].isOnline = (is_online == "1") ? true : false; - } else { - LOG(ERROR) << "Unexpected CPU number: " << words[0]; - return; - } - } - } -} +using ::android::base::StringPrintf; std::unordered_map<std::string, std::string> parseThermalPathMap(std::string_view prefix) { std::unordered_map<std::string, std::string> path_map; @@ -152,21 +70,21 @@ std::unordered_map<std::string, std::string> parseThermalPathMap(std::string_vie continue; } - if (!android::base::StartsWith(dp->d_name, prefix.data())) { + if (!::android::base::StartsWith(dp->d_name, prefix.data())) { continue; } - std::string path = android::base::StringPrintf("%s/%s/%s", kThermalSensorsRoot.data(), - dp->d_name, kThermalNameFile.data()); + std::string path = ::android::base::StringPrintf("%s/%s/%s", kThermalSensorsRoot.data(), + dp->d_name, kThermalNameFile.data()); std::string name; - if (!android::base::ReadFileToString(path, &name)) { + if (!::android::base::ReadFileToString(path, &name)) { PLOG(ERROR) << "Failed to read from " << path; continue; } path_map.emplace( - android::base::Trim(name), - android::base::StringPrintf("%s/%s", kThermalSensorsRoot.data(), dp->d_name)); + ::android::base::Trim(name), + ::android::base::StringPrintf("%s/%s", kThermalSensorsRoot.data(), dp->d_name)); } return path_map; @@ -185,32 +103,46 @@ ThermalHelper::ThermalHelper(const NotificationCallback &cb) cb_(cb) { const std::string config_path = "/vendor/etc/" + - android::base::GetProperty(kConfigProperty.data(), kConfigDefaultFileName.data()); + ::android::base::GetProperty(kConfigProperty.data(), kConfigDefaultFileName.data()); bool thermal_throttling_disabled = - android::base::GetBoolProperty(kThermalDisabledProperty.data(), false); - - is_initialized_ = ParseCoolingDevice(config_path, &cooling_device_info_map_) && - ParseSensorInfo(config_path, &sensor_info_map_); + ::android::base::GetBoolProperty(kThermalDisabledProperty.data(), false); + bool ret = true; + Json::Value config; + if (!ParseThermalConfig(config_path, &config)) { + LOG(ERROR) << "Failed to read JSON config"; + ret = false; + } - if (thermal_throttling_disabled) { - return; + if (!ParseCoolingDevice(config, &cooling_device_info_map_)) { + LOG(ERROR) << "Failed to parse cooling device info config"; + ret = false; } - if (!is_initialized_) { - LOG(FATAL) << "Failed to parse thermal configs"; + if (!ParseSensorInfo(config, &sensor_info_map_)) { + LOG(ERROR) << "Failed to parse sensor info config"; + ret = false; } auto tz_map = parseThermalPathMap(kSensorPrefix.data()); - auto cdev_map = parseThermalPathMap(kCoolingDevicePrefix.data()); + if (!initializeSensorMap(tz_map)) { + LOG(ERROR) << "Failed to initialize sensor map"; + ret = false; + } - is_initialized_ = initializeSensorMap(tz_map) && initializeCoolingDevices(cdev_map); + auto cdev_map = parseThermalPathMap(kCoolingDevicePrefix.data()); + if (!initializeCoolingDevices(cdev_map)) { + LOG(ERROR) << "Failed to initialize cooling device map"; + ret = false; + } - if (!is_initialized_) { - LOG(FATAL) << "ThermalHAL could not be initialized properly."; + if (!power_files_.registerPowerRailsToWatch(config)) { + LOG(ERROR) << "Failed to register power rails"; + ret = false; } - if (!power_files_.registerPowerRailsToWatch(config_path)) { - LOG(FATAL) << "Failed to register power rails"; + if (!thermal_stats_helper_.initializeStats(config, sensor_info_map_, + cooling_device_info_map_)) { + LOG(FATAL) << "Failed to initialize thermal stats"; } for (auto const &name_status_pair : sensor_info_map_) { @@ -221,51 +153,98 @@ ThermalHelper::ThermalHelper(const NotificationCallback &cb) .prev_hint_severity = ThrottlingSeverity::NONE, .last_update_time = boot_clock::time_point::min(), .thermal_cached = {NAN, boot_clock::time_point::min()}, + .emul_setting = nullptr, }; if (name_status_pair.second.throttling_info != nullptr) { if (!thermal_throttling_.registerThermalThrottling( name_status_pair.first, name_status_pair.second.throttling_info, cooling_device_info_map_)) { - LOG(FATAL) << name_status_pair.first << " failed to register thermal throttling"; + LOG(ERROR) << name_status_pair.first << " failed to register thermal throttling"; + ret = false; + break; } - } - // Update cooling device max state - for (auto &binded_cdev_info_pair : - name_status_pair.second.throttling_info->binded_cdev_info_map) { - const auto &cdev_info = cooling_device_info_map_.at(binded_cdev_info_pair.first); + // Update cooling device max state + for (auto &binded_cdev_info_pair : + name_status_pair.second.throttling_info->binded_cdev_info_map) { + const auto &cdev_info = cooling_device_info_map_.at(binded_cdev_info_pair.first); + + for (auto &cdev_ceiling : binded_cdev_info_pair.second.cdev_ceiling) { + if (cdev_ceiling > cdev_info.max_state) { + if (cdev_ceiling != std::numeric_limits<int>::max()) { + LOG(WARNING) << "Sensor " << name_status_pair.first << "'s " + << binded_cdev_info_pair.first + << " cdev_ceiling:" << cdev_ceiling + << " is higher than max state:" << cdev_info.max_state; + } + cdev_ceiling = cdev_info.max_state; + } + } + } + } + // Check the virtual sensor settings are valid + if (name_status_pair.second.virtual_sensor_info != nullptr) { + // Check if sub sensor setting is valid + for (size_t i = 0; + i < name_status_pair.second.virtual_sensor_info->linked_sensors.size(); i++) { + if (!isSubSensorValid( + name_status_pair.second.virtual_sensor_info->linked_sensors[i], + name_status_pair.second.virtual_sensor_info->linked_sensors_type[i])) { + LOG(ERROR) << name_status_pair.first << "'s link sensor " + << name_status_pair.second.virtual_sensor_info->linked_sensors[i] + << " is invalid"; + ret = false; + break; + } + } - for (auto &cdev_ceiling : binded_cdev_info_pair.second.cdev_ceiling) { - if (cdev_ceiling > cdev_info.max_state) { - if (cdev_ceiling != std::numeric_limits<int>::max()) { + // Check if the trigger sensor is valid + if (!name_status_pair.second.virtual_sensor_info->trigger_sensors.empty() && + name_status_pair.second.is_watch) { + for (size_t i = 0; + i < name_status_pair.second.virtual_sensor_info->trigger_sensors.size(); i++) { + if (sensor_info_map_.count( + name_status_pair.second.virtual_sensor_info->trigger_sensors[i])) { + sensor_info_map_[name_status_pair.second.virtual_sensor_info + ->trigger_sensors[i]] + .is_watch = true; + } else { LOG(ERROR) - << "Sensor " << name_status_pair.first << "'s " - << binded_cdev_info_pair.first << " cdev_ceiling:" << cdev_ceiling - << " is higher than max state:" << cdev_info.max_state; + << name_status_pair.first << "'s trigger sensor: " + << name_status_pair.second.virtual_sensor_info->trigger_sensors[i] + << " is invalid"; + ret = false; + break; } - cdev_ceiling = cdev_info.max_state; } } } + } - if (name_status_pair.second.virtual_sensor_info != nullptr && - !name_status_pair.second.virtual_sensor_info->trigger_sensor.empty() && - name_status_pair.second.is_watch) { - if (sensor_info_map_.count( - name_status_pair.second.virtual_sensor_info->trigger_sensor)) { - sensor_info_map_[name_status_pair.second.virtual_sensor_info->trigger_sensor] - .is_watch = true; - } else { - LOG(FATAL) << name_status_pair.first << "'s trigger sensor: " - << name_status_pair.second.virtual_sensor_info->trigger_sensor - << " is invalid"; - } + if (!connectToPowerHal()) { + LOG(ERROR) << "Fail to connect to Power Hal"; + } else { + updateSupportedPowerHints(); + } + + if (thermal_throttling_disabled) { + if (ret) { + clearAllThrottling(); + is_initialized_ = ret; + return; + } else { + sensor_info_map_.clear(); + cooling_device_info_map_.clear(); + return; } + } else if (!ret) { + LOG(FATAL) << "ThermalHAL could not be initialized properly."; } + is_initialized_ = ret; const bool thermal_genl_enabled = - android::base::GetBoolProperty(kThermalGenlProperty.data(), false); + ::android::base::GetBoolProperty(kThermalGenlProperty.data(), false); std::set<std::string> monitored_sensors; initializeTrip(tz_map, &monitored_sensors, thermal_genl_enabled); @@ -292,8 +271,8 @@ ThermalHelper::ThermalHelper(const NotificationCallback &cb) bool getThermalZoneTypeById(int tz_id, std::string *type) { std::string tz_type; std::string path = - android::base::StringPrintf("%s/%s%d/%s", kThermalSensorsRoot.data(), - kSensorPrefix.data(), tz_id, kThermalNameFile.data()); + ::android::base::StringPrintf("%s/%s%d/%s", kThermalSensorsRoot.data(), + kSensorPrefix.data(), tz_id, kThermalNameFile.data()); LOG(INFO) << "TZ Path: " << path; if (!::android::base::ReadFileToString(path, &tz_type)) { LOG(ERROR) << "Failed to read sensor: " << tz_type; @@ -306,8 +285,69 @@ bool getThermalZoneTypeById(int tz_id, std::string *type) { return true; } -bool ThermalHelper::readCoolingDevice(std::string_view cooling_device, - CoolingDevice_2_0 *out) const { +bool ThermalHelper::emulTemp(std::string_view target_sensor, const float value) { + LOG(INFO) << "Set " << target_sensor.data() << " emul_temp " + << "to " << value; + + std::lock_guard<std::shared_mutex> _lock(sensor_status_map_mutex_); + // Check the target sensor is valid + if (!sensor_status_map_.count(target_sensor.data())) { + LOG(ERROR) << "Cannot find target emul sensor: " << target_sensor.data(); + return false; + } + + sensor_status_map_.at(target_sensor.data()) + .emul_setting.reset(new EmulSetting{value, -1, true}); + + thermal_watcher_->wake(); + return true; +} + +bool ThermalHelper::emulSeverity(std::string_view target_sensor, const int severity) { + LOG(INFO) << "Set " << target_sensor.data() << " emul_severity " + << "to " << severity; + + std::lock_guard<std::shared_mutex> _lock(sensor_status_map_mutex_); + // Check the target sensor is valid + if (!sensor_status_map_.count(target_sensor.data())) { + LOG(ERROR) << "Cannot find target emul sensor: " << target_sensor.data(); + return false; + } + // Check the emul severity is valid + if (severity > static_cast<int>(kThrottlingSeverityCount)) { + LOG(ERROR) << "Invalid emul severity value " << severity; + return false; + } + + sensor_status_map_.at(target_sensor.data()) + .emul_setting.reset(new EmulSetting{NAN, severity, true}); + + thermal_watcher_->wake(); + return true; +} + +bool ThermalHelper::emulClear(std::string_view target_sensor) { + LOG(INFO) << "Clear " << target_sensor.data() << " emulation settings"; + + std::lock_guard<std::shared_mutex> _lock(sensor_status_map_mutex_); + if (target_sensor == "all") { + for (auto &sensor_status : sensor_status_map_) { + if (sensor_status.second.emul_setting != nullptr) { + sensor_status.second.emul_setting.reset(new EmulSetting{NAN, -1, true}); + } + } + } else if (sensor_status_map_.count(target_sensor.data()) && + sensor_status_map_.at(target_sensor.data()).emul_setting != nullptr) { + sensor_status_map_.at(target_sensor.data()) + .emul_setting.reset(new EmulSetting{NAN, -1, true}); + } else { + LOG(ERROR) << "Cannot find target emul sensor: " << target_sensor.data(); + return false; + } + return true; +} + +bool ThermalHelper::readCoolingDevice(std::string_view cooling_device, CoolingDevice *out) const { // Read the file. If the file can't be read temp will be empty string. std::string data; @@ -326,39 +366,16 @@ bool ThermalHelper::readCoolingDevice(std::string_view cooling_device, return true; } -bool ThermalHelper::readTemperature(std::string_view sensor_name, Temperature_1_0 *out) { - // Return fail if the thermal sensor cannot be read. - float temp; - if (!readThermalSensor(sensor_name, &temp, false)) { - LOG(ERROR) << "readTemperature: failed to read sensor: " << sensor_name; - return false; - } - - const SensorInfo &sensor_info = sensor_info_map_.at(sensor_name.data()); - TemperatureType_1_0 type = - (static_cast<int>(sensor_info.type) > static_cast<int>(TemperatureType_1_0::SKIN)) - ? TemperatureType_1_0::UNKNOWN - : static_cast<TemperatureType_1_0>(sensor_info.type); - out->type = type; - out->name = sensor_name.data(); - out->currentValue = temp * sensor_info.multiplier; - out->throttlingThreshold = - sensor_info.hot_thresholds[static_cast<size_t>(ThrottlingSeverity::SEVERE)]; - out->shutdownThreshold = - sensor_info.hot_thresholds[static_cast<size_t>(ThrottlingSeverity::SHUTDOWN)]; - out->vrThrottlingThreshold = sensor_info.vr_threshold; - - return true; -} - bool ThermalHelper::readTemperature( - std::string_view sensor_name, Temperature_2_0 *out, - std::pair<ThrottlingSeverity, ThrottlingSeverity> *throtting_status, - const bool force_sysfs) { + std::string_view sensor_name, Temperature *out, + std::pair<ThrottlingSeverity, ThrottlingSeverity> *throttling_status, + const bool force_no_cache) { // Return fail if the thermal sensor cannot be read. float temp; + std::map<std::string, float> sensor_log_map; + auto &sensor_status = sensor_status_map_.at(sensor_name.data()); - if (!readThermalSensor(sensor_name, &temp, force_sysfs)) { + if (!readThermalSensor(sensor_name, &temp, force_no_cache, &sensor_log_map)) { LOG(ERROR) << "readTemperature: failed to read sensor: " << sensor_name; return false; } @@ -376,20 +393,37 @@ bool ThermalHelper::readTemperature( { // reader lock, readTemperature will be called in Binder call and the watcher thread. std::shared_lock<std::shared_mutex> _lock(sensor_status_map_mutex_); - prev_hot_severity = sensor_status_map_.at(sensor_name.data()).prev_hot_severity; - prev_cold_severity = sensor_status_map_.at(sensor_name.data()).prev_cold_severity; + prev_hot_severity = sensor_status.prev_hot_severity; + prev_cold_severity = sensor_status.prev_cold_severity; } status = getSeverityFromThresholds(sensor_info.hot_thresholds, sensor_info.cold_thresholds, sensor_info.hot_hysteresis, sensor_info.cold_hysteresis, prev_hot_severity, prev_cold_severity, out->value); } - if (throtting_status) { - *throtting_status = status; + + if (throttling_status) { + *throttling_status = status; } - out->throttlingStatus = static_cast<size_t>(status.first) > static_cast<size_t>(status.second) - ? status.first - : status.second; + if (sensor_status.emul_setting != nullptr && sensor_status.emul_setting->emul_severity >= 0) { + std::shared_lock<std::shared_mutex> _lock(sensor_status_map_mutex_); + out->throttlingStatus = + static_cast<ThrottlingSeverity>(sensor_status.emul_setting->emul_severity); + } else { + out->throttlingStatus = + static_cast<size_t>(status.first) > static_cast<size_t>(status.second) + ? status.first + : status.second; + } + if (sensor_info.is_watch) { + std::ostringstream sensor_log; + for (const auto &sensor_log_pair : sensor_log_map) { + sensor_log << sensor_log_pair.first << ":" << sensor_log_pair.second << " "; + } + // Update sensor temperature time in state + thermal_stats_helper_.updateSensorTempStatsBySeverity(sensor_name, out->throttlingStatus); + LOG(INFO) << sensor_name.data() << ":" << out->value << " raw data: " << sensor_log.str(); + } return true; } @@ -409,34 +443,26 @@ bool ThermalHelper::readTemperatureThreshold(std::string_view sensor_name, out->type = sensor_info.type; out->name = sensor_name.data(); - out->hotThrottlingThresholds = sensor_info.hot_thresholds; - out->coldThrottlingThresholds = sensor_info.cold_thresholds; - out->vrThrottlingThreshold = sensor_info.vr_threshold; + out->hotThrottlingThresholds = + std::vector(sensor_info.hot_thresholds.begin(), sensor_info.hot_thresholds.end()); + out->coldThrottlingThresholds = + std::vector(sensor_info.cold_thresholds.begin(), sensor_info.cold_thresholds.end()); return true; } void ThermalHelper::updateCoolingDevices(const std::vector<std::string> &updated_cdev) { int max_state; - const auto &thermal_throttling_status_map = thermal_throttling_.GetThermalThrottlingStatusMap(); - for (const auto &target_cdev : updated_cdev) { - max_state = 0; - for (const auto &thermal_throttling_status_pair : thermal_throttling_status_map) { - if (!thermal_throttling_status_pair.second.cdev_status_map.count(target_cdev)) { - continue; - } - const auto state = - thermal_throttling_status_pair.second.cdev_status_map.at(target_cdev); - if (state > max_state) { - max_state = state; + if (thermal_throttling_.getCdevMaxRequest(target_cdev, &max_state)) { + if (cooling_devices_.writeCdevFile(target_cdev, std::to_string(max_state))) { + ATRACE_INT(target_cdev.c_str(), max_state); + LOG(INFO) << "Successfully update cdev " << target_cdev << " sysfs to " + << max_state; + } else { + LOG(ERROR) << "Failed to update cdev " << target_cdev << " sysfs to " << max_state; } } - if (cooling_devices_.writeCdevFile(target_cdev, std::to_string(max_state))) { - LOG(INFO) << "Successfully update cdev " << target_cdev << " sysfs to " << max_state; - } else { - LOG(ERROR) << "Failed to update cdev " << target_cdev << " sysfs to " << max_state; - } } } @@ -450,7 +476,7 @@ std::pair<ThrottlingSeverity, ThrottlingSeverity> ThermalHelper::getSeverityFrom ThrottlingSeverity ret_cold = ThrottlingSeverity::NONE; ThrottlingSeverity ret_cold_hysteresis = ThrottlingSeverity::NONE; - // Here we want to control the iteration from high to low, and hidl_enum_range doesn't support + // Here we want to control the iteration from high to low, and ::ndk::enum_range doesn't support // a reverse iterator yet. for (size_t i = static_cast<size_t>(ThrottlingSeverity::SHUTDOWN); i > static_cast<size_t>(ThrottlingSeverity::NONE); --i) { @@ -481,6 +507,57 @@ std::pair<ThrottlingSeverity, ThrottlingSeverity> ThermalHelper::getSeverityFrom return std::make_pair(ret_hot, ret_cold); } +bool ThermalHelper::isSubSensorValid(std::string_view sensor_data, + const SensorFusionType sensor_fusion_type) { + switch (sensor_fusion_type) { + case SensorFusionType::SENSOR: + if (!sensor_info_map_.count(sensor_data.data())) { + LOG(ERROR) << "Cannot find " << sensor_data.data() << " from sensor info map"; + return false; + } + break; + case SensorFusionType::ODPM: + if (!GetPowerStatusMap().count(sensor_data.data())) { + LOG(ERROR) << "Cannot find " << sensor_data.data() << " from power status map"; + return false; + } + break; + default: + break; + } + return true; +} + +void ThermalHelper::clearAllThrottling(void) { + // Clear the CDEV request + for (const auto &cdev_info_pair : cooling_device_info_map_) { + cooling_devices_.writeCdevFile(cdev_info_pair.first, "0"); + } + + for (auto &sensor_info_pair : sensor_info_map_) { + sensor_info_pair.second.is_watch = false; + sensor_info_pair.second.throttling_info.reset(); + sensor_info_pair.second.hot_thresholds.fill(NAN); + sensor_info_pair.second.cold_thresholds.fill(NAN); + Temperature temp = { + .type = sensor_info_pair.second.type, + .name = sensor_info_pair.first, + .value = NAN, + .throttlingStatus = ThrottlingSeverity::NONE, + }; + // Send callbacks with NONE severity + if (sensor_info_pair.second.send_cb && cb_) { + cb_(temp); + } + // Disable thermal power hints + if (sensor_info_pair.second.send_powerhint) { + for (const auto &severity : ::ndk::enum_range<ThrottlingSeverity>()) { + power_hal_service_.setMode(sensor_info_pair.first, severity, false); + } + } + } +} + bool ThermalHelper::initializeSensorMap( const std::unordered_map<std::string, std::string> &path_map) { for (const auto &sensor_info_pair : sensor_info_map_) { @@ -495,8 +572,8 @@ bool ThermalHelper::initializeSensorMap( std::string path; if (sensor_info_pair.second.temp_path.empty()) { - path = android::base::StringPrintf("%s/%s", path_map.at(sensor_name.data()).c_str(), - kSensorTempSuffix.data()); + path = ::android::base::StringPrintf("%s/%s", path_map.at(sensor_name.data()).c_str(), + kSensorTempSuffix.data()); } else { path = sensor_info_pair.second.temp_path; } @@ -523,8 +600,8 @@ bool ThermalHelper::initializeCoolingDevices( if (!cooling_device_info_pair.second.read_path.empty()) { read_path = cooling_device_info_pair.second.read_path.data(); } else { - read_path = android::base::StringPrintf("%s/%s", path.data(), - kCoolingDeviceCurStateSuffix.data()); + read_path = ::android::base::StringPrintf("%s/%s", path.data(), + kCoolingDeviceCurStateSuffix.data()); } if (!cooling_devices_.addThermalFile(cooling_device_name, read_path)) { LOG(ERROR) << "Could not add " << cooling_device_name @@ -532,10 +609,10 @@ bool ThermalHelper::initializeCoolingDevices( return false; } - std::string state2power_path = android::base::StringPrintf( + std::string state2power_path = ::android::base::StringPrintf( "%s/%s", path.data(), kCoolingDeviceState2powerSuffix.data()); std::string state2power_str; - if (android::base::ReadFileToString(state2power_path, &state2power_str)) { + if (::android::base::ReadFileToString(state2power_path, &state2power_str)) { LOG(INFO) << "Cooling device " << cooling_device_info_pair.first << " use state2power read from sysfs"; cooling_device_info_pair.second.state2power.clear(); @@ -554,14 +631,14 @@ bool ThermalHelper::initializeCoolingDevices( // Get max cooling device request state std::string max_state; - std::string max_state_path = android::base::StringPrintf( + std::string max_state_path = ::android::base::StringPrintf( "%s/%s", path.data(), kCoolingDeviceMaxStateSuffix.data()); - if (!android::base::ReadFileToString(max_state_path, &max_state)) { + if (!::android::base::ReadFileToString(max_state_path, &max_state)) { LOG(ERROR) << cooling_device_info_pair.first << " could not open max state file:" << max_state_path; cooling_device_info_pair.second.max_state = std::numeric_limits<int>::max(); } else { - cooling_device_info_pair.second.max_state = std::stoi(android::base::Trim(max_state)); + cooling_device_info_pair.second.max_state = std::stoi(::android::base::Trim(max_state)); LOG(INFO) << "Cooling device " << cooling_device_info_pair.first << " max state: " << cooling_device_info_pair.second.max_state << " state2power number: " @@ -579,13 +656,13 @@ bool ThermalHelper::initializeCoolingDevices( // Add cooling device path for thermalHAL to request state cooling_device_name = - android::base::StringPrintf("%s_%s", cooling_device_name.c_str(), "w"); + ::android::base::StringPrintf("%s_%s", cooling_device_name.c_str(), "w"); std::string write_path; if (!cooling_device_info_pair.second.write_path.empty()) { write_path = cooling_device_info_pair.second.write_path.data(); } else { - write_path = android::base::StringPrintf("%s/%s", path.data(), - kCoolingDeviceCurStateSuffix.data()); + write_path = ::android::base::StringPrintf("%s/%s", path.data(), + kCoolingDeviceCurStateSuffix.data()); } if (!cooling_devices_.addThermalFile(cooling_device_name, write_path)) { @@ -615,16 +692,16 @@ void ThermalHelper::initializeTrip(const std::unordered_map<std::string, std::st std::string_view tz_path = path_map.at(sensor_name.data()); std::string tz_policy; std::string path = - android::base::StringPrintf("%s/%s", (tz_path.data()), kSensorPolicyFile.data()); + ::android::base::StringPrintf("%s/%s", (tz_path.data()), kSensorPolicyFile.data()); if (thermal_genl_enabled) { trip_update = true; } else { // Check if thermal zone support uevent notify - if (!android::base::ReadFileToString(path, &tz_policy)) { + if (!::android::base::ReadFileToString(path, &tz_policy)) { LOG(ERROR) << sensor_name << " could not open tz policy file:" << path; } else { - tz_policy = android::base::Trim(tz_policy); + tz_policy = ::android::base::Trim(tz_policy); if (tz_policy != kUserSpaceSuffix) { LOG(ERROR) << sensor_name << " does not support uevent notify"; } else { @@ -640,9 +717,9 @@ void ThermalHelper::initializeTrip(const std::unordered_map<std::string, std::st // Update trip_point_0_temp threshold std::string threshold = std::to_string(static_cast<int>( sensor_info.second.hot_thresholds[i] / sensor_info.second.multiplier)); - path = android::base::StringPrintf("%s/%s", (tz_path.data()), - kSensorTripPointTempZeroFile.data()); - if (!android::base::WriteStringToFile(threshold, path)) { + path = ::android::base::StringPrintf("%s/%s", (tz_path.data()), + kSensorTripPointTempZeroFile.data()); + if (!::android::base::WriteStringToFile(threshold, path)) { LOG(ERROR) << "fail to update " << sensor_name << " trip point: " << path << " to " << threshold; trip_update = false; @@ -651,9 +728,9 @@ void ThermalHelper::initializeTrip(const std::unordered_map<std::string, std::st // Update trip_point_0_hyst threshold threshold = std::to_string(static_cast<int>( sensor_info.second.hot_hysteresis[i] / sensor_info.second.multiplier)); - path = android::base::StringPrintf("%s/%s", (tz_path.data()), - kSensorTripPointHystZeroFile.data()); - if (!android::base::WriteStringToFile(threshold, path)) { + path = ::android::base::StringPrintf("%s/%s", (tz_path.data()), + kSensorTripPointHystZeroFile.data()); + if (!::android::base::WriteStringToFile(threshold, path)) { LOG(ERROR) << "fail to update " << sensor_name << "trip hyst" << threshold << path; trip_update = false; @@ -677,33 +754,12 @@ void ThermalHelper::initializeTrip(const std::unordered_map<std::string, std::st } } -bool ThermalHelper::fillTemperatures(hidl_vec<Temperature_1_0> *temperatures) { - std::vector<Temperature_1_0> ret; - for (const auto &name_info_pair : sensor_info_map_) { - Temperature_1_0 temp; - - if (name_info_pair.second.is_hidden) { - continue; - } - - if (readTemperature(name_info_pair.first, &temp)) { - ret.emplace_back(std::move(temp)); - } else { - LOG(ERROR) << __func__ - << ": error reading temperature for sensor: " << name_info_pair.first; - return false; - } - } - *temperatures = ret; - return ret.size() > 0; -} - bool ThermalHelper::fillCurrentTemperatures(bool filterType, bool filterCallback, - TemperatureType_2_0 type, - hidl_vec<Temperature_2_0> *temperatures) { - std::vector<Temperature_2_0> ret; + TemperatureType type, + std::vector<Temperature> *temperatures) { + std::vector<Temperature> ret; for (const auto &name_info_pair : sensor_info_map_) { - Temperature_2_0 temp; + Temperature temp; if (name_info_pair.second.is_hidden) { continue; } @@ -724,8 +780,8 @@ bool ThermalHelper::fillCurrentTemperatures(bool filterType, bool filterCallback return ret.size() > 0; } -bool ThermalHelper::fillTemperatureThresholds(bool filterType, TemperatureType_2_0 type, - hidl_vec<TemperatureThreshold> *thresholds) const { +bool ThermalHelper::fillTemperatureThresholds(bool filterType, TemperatureType type, + std::vector<TemperatureThreshold> *thresholds) const { std::vector<TemperatureThreshold> ret; for (const auto &name_info_pair : sensor_info_map_) { TemperatureThreshold temp; @@ -748,10 +804,10 @@ bool ThermalHelper::fillTemperatureThresholds(bool filterType, TemperatureType_2 } bool ThermalHelper::fillCurrentCoolingDevices(bool filterType, CoolingType type, - hidl_vec<CoolingDevice_2_0> *cooling_devices) const { - std::vector<CoolingDevice_2_0> ret; + std::vector<CoolingDevice> *cooling_devices) const { + std::vector<CoolingDevice> ret; for (const auto &name_info_pair : cooling_device_info_map_) { - CoolingDevice_2_0 value; + CoolingDevice value; if (filterType && name_info_pair.second.type != type) { continue; } @@ -766,23 +822,36 @@ bool ThermalHelper::fillCurrentCoolingDevices(bool filterType, CoolingType type, return ret.size() > 0; } -bool ThermalHelper::fillCpuUsages(hidl_vec<CpuUsage> *cpu_usages) const { - cpu_usages->resize(kMaxCpus); - for (int i = 0; i < kMaxCpus; i++) { - (*cpu_usages)[i].name = StringPrintf("cpu%d", i); - (*cpu_usages)[i].active = 0; - (*cpu_usages)[i].total = 0; - (*cpu_usages)[i].isOnline = false; +bool ThermalHelper::readDataByType(std::string_view sensor_data, float *reading_value, + const SensorFusionType type, const bool force_no_cache, + std::map<std::string, float> *sensor_log_map) { + switch (type) { + case SensorFusionType::SENSOR: + if (!readThermalSensor(sensor_data.data(), reading_value, force_no_cache, + sensor_log_map)) { + LOG(ERROR) << "Failed to get " << sensor_data.data() << " data"; + return false; + } + break; + case SensorFusionType::ODPM: + *reading_value = GetPowerStatusMap().at(sensor_data.data()).last_updated_avg_power; + if (std::isnan(*reading_value)) { + LOG(INFO) << "Power data " << sensor_data.data() << " is under collecting"; + return false; + } + (*sensor_log_map)[sensor_data.data()] = *reading_value; + break; + default: + break; } - parseCpuUsagesFileAndAssignUsages(cpu_usages); return true; } bool ThermalHelper::readThermalSensor(std::string_view sensor_name, float *temp, - const bool force_sysfs) { + const bool force_no_cache, + std::map<std::string, float> *sensor_log_map) { float temp_val = 0.0; std::string file_reading; - std::string log_buf; boot_clock::time_point now = boot_clock::now(); ATRACE_NAME(StringPrintf("ThermalHelper::readThermalSensor - %s", sensor_name.data()).c_str()); @@ -794,13 +863,24 @@ bool ThermalHelper::readThermalSensor(std::string_view sensor_name, float *temp, const auto &sensor_info = sensor_info_map_.at(sensor_name.data()); auto &sensor_status = sensor_status_map_.at(sensor_name.data()); - // Check if thermal data need to be read from buffer - if (!force_sysfs && (sensor_status.thermal_cached.timestamp != boot_clock::time_point::min()) && + { + std::shared_lock<std::shared_mutex> _lock(sensor_status_map_mutex_); + if (sensor_status.emul_setting != nullptr && + !isnan(sensor_status.emul_setting->emul_temp)) { + *temp = sensor_status.emul_setting->emul_temp; + return true; + } + } + + // Check if thermal data need to be read from cache + if (!force_no_cache && + (sensor_status.thermal_cached.timestamp != boot_clock::time_point::min()) && (std::chrono::duration_cast<std::chrono::milliseconds>( now - sensor_status.thermal_cached.timestamp) < sensor_info.time_resolution) && !isnan(sensor_status.thermal_cached.temp)) { *temp = sensor_status.thermal_cached.temp; - LOG(VERBOSE) << "read " << sensor_name.data() << " from buffer, value:" << *temp; + (*sensor_log_map)[sensor_name.data()] = *temp; + ATRACE_INT((sensor_name.data() + std::string("-cached")).c_str(), static_cast<int>(*temp)); return true; } @@ -818,17 +898,16 @@ bool ThermalHelper::readThermalSensor(std::string_view sensor_name, float *temp, } else { for (size_t i = 0; i < sensor_info.virtual_sensor_info->linked_sensors.size(); i++) { float sensor_reading = 0.0; - if (!readThermalSensor(sensor_info.virtual_sensor_info->linked_sensors[i], - &sensor_reading, force_sysfs)) { - return false; + // Get the sensor reading data + if (!readDataByType(sensor_info.virtual_sensor_info->linked_sensors[i], &sensor_reading, + sensor_info.virtual_sensor_info->linked_sensors_type[i], + force_no_cache, sensor_log_map)) { + LOG(ERROR) << "Failed to read " << sensor_name.data() << "'s linked sensor " + << sensor_info.virtual_sensor_info->linked_sensors[i]; } - log_buf.append(StringPrintf("(%s: %0.2f)", - sensor_info.virtual_sensor_info->linked_sensors[i].c_str(), - sensor_reading)); if (std::isnan(sensor_info.virtual_sensor_info->coefficients[i])) { return false; } - float coefficient = sensor_info.virtual_sensor_info->coefficients[i]; switch (sensor_info.virtual_sensor_info->formula) { case FormulaOption::COUNT_THRESHOLD: @@ -855,16 +934,18 @@ bool ThermalHelper::readThermalSensor(std::string_view sensor_name, float *temp, break; } } - LOG(VERBOSE) << sensor_name.data() << "'s sub sensors:" << log_buf; *temp = (temp_val + sensor_info.virtual_sensor_info->offset); } + (*sensor_log_map)[sensor_name.data()] = *temp; + ATRACE_INT(sensor_name.data(), static_cast<int>(*temp)); { std::unique_lock<std::shared_mutex> _lock(sensor_status_map_mutex_); sensor_status.thermal_cached.temp = *temp; sensor_status.thermal_cached.timestamp = now; } - + auto real_temp = (*temp) * sensor_info.multiplier; + thermal_stats_helper_.updateSensorTempStatsByThreshold(sensor_name, real_temp); return true; } @@ -872,7 +953,7 @@ bool ThermalHelper::readThermalSensor(std::string_view sensor_name, float *temp, // uevent_sensors is the set of sensors which trigger uevent from thermal core driver. std::chrono::milliseconds ThermalHelper::thermalWatcherCallbackFunc( const std::set<std::string> &uevent_sensors) { - std::vector<Temperature_2_0> temps; + std::vector<Temperature> temps; std::vector<std::string> cooling_devices_to_update; boot_clock::time_point now = boot_clock::now(); auto min_sleep_ms = std::chrono::milliseconds::max(); @@ -881,8 +962,8 @@ std::chrono::milliseconds ThermalHelper::thermalWatcherCallbackFunc( ATRACE_CALL(); for (auto &name_status_pair : sensor_status_map_) { bool force_update = false; - bool force_sysfs = false; - Temperature_2_0 temp; + bool force_no_cache = false; + Temperature temp; TemperatureThreshold threshold; SensorStatus &sensor_status = name_status_pair.second; const SensorInfo &sensor_info = sensor_info_map_.at(name_status_pair.first); @@ -902,39 +983,55 @@ std::chrono::milliseconds ThermalHelper::thermalWatcherCallbackFunc( : sensor_info.polling_delay; if (sensor_info.virtual_sensor_info != nullptr && - !sensor_info.virtual_sensor_info->trigger_sensor.empty()) { - const auto trigger_sensor_status = - sensor_status_map_.at(sensor_info.virtual_sensor_info->trigger_sensor); - if (trigger_sensor_status.severity != ThrottlingSeverity::NONE) { - sleep_ms = sensor_info.passive_delay; + !sensor_info.virtual_sensor_info->trigger_sensors.empty()) { + for (size_t i = 0; i < sensor_info.virtual_sensor_info->trigger_sensors.size(); i++) { + const auto &trigger_sensor_status = + sensor_status_map_.at(sensor_info.virtual_sensor_info->trigger_sensors[i]); + if (trigger_sensor_status.severity != ThrottlingSeverity::NONE) { + sleep_ms = sensor_info.passive_delay; + break; + } } } // Check if the sensor need to be updated if (sensor_status.last_update_time == boot_clock::time_point::min()) { force_update = true; - LOG(VERBOSE) << "Force update " << name_status_pair.first - << "'s temperature after booting"; } else { time_elapsed_ms = std::chrono::duration_cast<std::chrono::milliseconds>( now - sensor_status.last_update_time); - if (time_elapsed_ms > sleep_ms) { - // Update the sensor because sleep timeout + if (uevent_sensors.size()) { + if (sensor_info.virtual_sensor_info != nullptr) { + for (size_t i = 0; i < sensor_info.virtual_sensor_info->trigger_sensors.size(); + i++) { + if (uevent_sensors.find( + sensor_info.virtual_sensor_info->trigger_sensors[i]) != + uevent_sensors.end()) { + force_update = true; + break; + } + } + } else if (uevent_sensors.find(name_status_pair.first) != uevent_sensors.end()) { + force_update = true; + force_no_cache = true; + } + } else if (time_elapsed_ms > sleep_ms) { force_update = true; - } else if (uevent_sensors.size() && - uevent_sensors.find((sensor_info.virtual_sensor_info != nullptr) - ? sensor_info.virtual_sensor_info->trigger_sensor - : name_status_pair.first) != - uevent_sensors.end()) { - // Force update the sensor from sysfs + } + } + { + std::lock_guard<std::shared_mutex> _lock(sensor_status_map_mutex_); + if (sensor_status.emul_setting != nullptr && + sensor_status.emul_setting->pending_update) { force_update = true; - force_sysfs = true; + sensor_status.emul_setting->pending_update = false; + LOG(INFO) << "Update " << name_status_pair.first.data() + << " right away with emul setting"; } } - LOG(VERBOSE) << "sensor " << name_status_pair.first - << ": time_elpased=" << time_elapsed_ms.count() + << ": time_elapsed=" << time_elapsed_ms.count() << ", sleep_ms=" << sleep_ms.count() << ", force_update = " << force_update - << ", force_sysfs = " << force_sysfs; + << ", force_no_cache = " << force_no_cache; if (!force_update) { auto timeout_remaining = sleep_ms - time_elapsed_ms; @@ -946,8 +1043,8 @@ std::chrono::milliseconds ThermalHelper::thermalWatcherCallbackFunc( continue; } - std::pair<ThrottlingSeverity, ThrottlingSeverity> throtting_status; - if (!readTemperature(name_status_pair.first, &temp, &throtting_status, force_sysfs)) { + std::pair<ThrottlingSeverity, ThrottlingSeverity> throttling_status; + if (!readTemperature(name_status_pair.first, &temp, &throttling_status, force_no_cache)) { LOG(ERROR) << __func__ << ": error reading temperature for sensor: " << name_status_pair.first; continue; @@ -961,11 +1058,11 @@ std::chrono::milliseconds ThermalHelper::thermalWatcherCallbackFunc( { // writer lock std::unique_lock<std::shared_mutex> _lock(sensor_status_map_mutex_); - if (throtting_status.first != sensor_status.prev_hot_severity) { - sensor_status.prev_hot_severity = throtting_status.first; + if (throttling_status.first != sensor_status.prev_hot_severity) { + sensor_status.prev_hot_severity = throttling_status.first; } - if (throtting_status.second != sensor_status.prev_cold_severity) { - sensor_status.prev_cold_severity = throtting_status.second; + if (throttling_status.second != sensor_status.prev_cold_severity) { + sensor_status.prev_cold_severity = throttling_status.second; } if (temp.throttlingStatus != sensor_status.severity) { temps.push_back(temp); @@ -982,19 +1079,17 @@ std::chrono::milliseconds ThermalHelper::thermalWatcherCallbackFunc( } if (sensor_status.severity == ThrottlingSeverity::NONE) { - LOG(VERBOSE) << temp.name << ": " << temp.value; thermal_throttling_.clearThrottlingData(name_status_pair.first, sensor_info); } else { - LOG(INFO) << temp.name << ": " << temp.value; // update thermal throttling request thermal_throttling_.thermalThrottlingUpdate( temp, sensor_info, sensor_status.severity, time_elapsed_ms, power_files_.GetPowerStatusMap(), cooling_device_info_map_); } - thermal_throttling_.computeCoolingDevicesRequest(name_status_pair.first, sensor_info, - sensor_status.severity, - &cooling_devices_to_update); + thermal_throttling_.computeCoolingDevicesRequest( + name_status_pair.first, sensor_info, sensor_status.severity, + &cooling_devices_to_update, &thermal_stats_helper_); if (min_sleep_ms > sleep_ms) { min_sleep_ms = sleep_ms; } @@ -1020,6 +1115,11 @@ std::chrono::milliseconds ThermalHelper::thermalWatcherCallbackFunc( } } + int count_failed_reporting = thermal_stats_helper_.reportStats(); + if (count_failed_reporting != 0) { + LOG(ERROR) << "Failed to report " << count_failed_reporting << " thermal stats"; + } + return min_sleep_ms; } @@ -1033,7 +1133,7 @@ void ThermalHelper::updateSupportedPowerHints() { continue; } ThrottlingSeverity current_severity = ThrottlingSeverity::NONE; - for (const auto &severity : hidl_enum_range<ThrottlingSeverity>()) { + for (const auto &severity : ::ndk::enum_range<ThrottlingSeverity>()) { if (severity == ThrottlingSeverity::NONE) { supported_powerhint_map_[name_status_pair.first][ThrottlingSeverity::NONE] = ThrottlingSeverity::NONE; @@ -1053,7 +1153,7 @@ void ThermalHelper::updateSupportedPowerHints() { } } -void ThermalHelper::sendPowerExtHint(const Temperature_2_0 &t) { +void ThermalHelper::sendPowerExtHint(const Temperature &t) { ATRACE_CALL(); std::lock_guard<std::shared_mutex> lock(sensor_status_map_mutex_); ThrottlingSeverity prev_hint_severity; @@ -1074,7 +1174,7 @@ void ThermalHelper::sendPowerExtHint(const Temperature_2_0 &t) { sensor_status_map_[t.name].prev_hint_severity = current_hint_severity; } } // namespace implementation -} // namespace V2_0 } // namespace thermal } // namespace hardware } // namespace android +} // namespace aidl diff --git a/thermal/thermal-helper.h b/thermal/thermal-helper.h index 6b7cd9a9..3b790e3e 100644 --- a/thermal/thermal-helper.h +++ b/thermal/thermal-helper.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2018 The Android Open Source Project + * Copyright (C) 2022 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. @@ -16,8 +16,11 @@ #pragma once +#include <aidl/android/hardware/thermal/IThermal.h> + #include <array> #include <chrono> +#include <map> #include <mutex> #include <shared_mutex> #include <string> @@ -30,30 +33,19 @@ #include "utils/powerhal_helper.h" #include "utils/thermal_files.h" #include "utils/thermal_info.h" +#include "utils/thermal_stats_helper.h" #include "utils/thermal_throttling.h" #include "utils/thermal_watcher.h" +namespace aidl { namespace android { namespace hardware { namespace thermal { -namespace V2_0 { namespace implementation { -using ::android::hardware::hidl_vec; -using ::android::hardware::thermal::V1_0::CpuUsage; -using ::android::hardware::thermal::V2_0::CoolingType; -using ::android::hardware::thermal::V2_0::IThermal; -using CoolingDevice_1_0 = ::android::hardware::thermal::V1_0::CoolingDevice; -using CoolingDevice_2_0 = ::android::hardware::thermal::V2_0::CoolingDevice; -using Temperature_1_0 = ::android::hardware::thermal::V1_0::Temperature; -using Temperature_2_0 = ::android::hardware::thermal::V2_0::Temperature; -using TemperatureType_1_0 = ::android::hardware::thermal::V1_0::TemperatureType; -using TemperatureType_2_0 = ::android::hardware::thermal::V2_0::TemperatureType; -using ::android::hardware::thermal::V2_0::TemperatureThreshold; -using ::android::hardware::thermal::V2_0::ThrottlingSeverity; - -using NotificationCallback = std::function<void(const Temperature_2_0 &t)>; -using NotificationTime = std::chrono::time_point<std::chrono::steady_clock>; +using ::android::sp; + +using NotificationCallback = std::function<void(const Temperature &t)>; // Get thermal_zone type bool getThermalZoneTypeById(int tz_id, std::string *); @@ -63,6 +55,12 @@ struct ThermalSample { boot_clock::time_point timestamp; }; +struct EmulSetting { + float emul_temp; + int emul_severity; + bool pending_update; +}; + struct SensorStatus { ThrottlingSeverity severity; ThrottlingSeverity prev_hot_severity; @@ -70,6 +68,7 @@ struct SensorStatus { ThrottlingSeverity prev_hint_severity; boot_clock::time_point last_update_time; ThermalSample thermal_cached; + std::unique_ptr<EmulSetting> emul_setting; }; class ThermalHelper { @@ -77,30 +76,32 @@ class ThermalHelper { explicit ThermalHelper(const NotificationCallback &cb); ~ThermalHelper() = default; - bool fillTemperatures(hidl_vec<Temperature_1_0> *temperatures); - bool fillCurrentTemperatures(bool filterType, bool filterCallback, TemperatureType_2_0 type, - hidl_vec<Temperature_2_0> *temperatures); - bool fillTemperatureThresholds(bool filterType, TemperatureType_2_0 type, - hidl_vec<TemperatureThreshold> *thresholds) const; + bool fillCurrentTemperatures(bool filterType, bool filterCallback, TemperatureType type, + std::vector<Temperature> *temperatures); + bool fillTemperatureThresholds(bool filterType, TemperatureType type, + std::vector<TemperatureThreshold> *thresholds) const; bool fillCurrentCoolingDevices(bool filterType, CoolingType type, - hidl_vec<CoolingDevice_2_0> *coolingdevices) const; - bool fillCpuUsages(hidl_vec<CpuUsage> *cpu_usages) const; + std::vector<CoolingDevice> *coolingdevices) const; + bool emulTemp(std::string_view target_sensor, const float temp); + bool emulSeverity(std::string_view target_sensor, const int severity); + bool emulClear(std::string_view target_sensor); - // Dissallow copy and assign. + // Disallow copy and assign. ThermalHelper(const ThermalHelper &) = delete; void operator=(const ThermalHelper &) = delete; bool isInitializedOk() const { return is_initialized_; } // Read the temperature of a single sensor. - bool readTemperature(std::string_view sensor_name, Temperature_1_0 *out); + bool readTemperature(std::string_view sensor_name, Temperature *out); bool readTemperature( - std::string_view sensor_name, Temperature_2_0 *out, + std::string_view sensor_name, Temperature *out, std::pair<ThrottlingSeverity, ThrottlingSeverity> *throtting_status = nullptr, const bool force_sysfs = false); + bool readTemperatureThreshold(std::string_view sensor_name, TemperatureThreshold *out) const; // Read the value of a single cooling device. - bool readCoolingDevice(std::string_view cooling_device, CoolingDevice_2_0 *out) const; + bool readCoolingDevice(std::string_view cooling_device, CoolingDevice *out) const; // Get SensorInfo Map const std::unordered_map<std::string, SensorInfo> &GetSensorInfoMap() const { return sensor_info_map_; @@ -128,7 +129,18 @@ class ThermalHelper { const std::unordered_map<std::string, PowerStatus> &GetPowerStatusMap() const { return power_files_.GetPowerStatusMap(); } - void sendPowerExtHint(const Temperature_2_0 &t); + + // Get Thermal Stats Sensor Map + const std::unordered_map<std::string, SensorTempStats> GetSensorTempStatsSnapshot() { + return thermal_stats_helper_.GetSensorTempStatsSnapshot(); + } + // Get Thermal Stats Sensor, Binded Cdev State Request Map + const std::unordered_map<std::string, std::unordered_map<std::string, ThermalStats<int>>> + GetSensorCoolingDeviceRequestStatsSnapshot() { + return thermal_stats_helper_.GetSensorCoolingDeviceRequestStatsSnapshot(); + } + + void sendPowerExtHint(const Temperature &t); bool isAidlPowerHalExist() { return power_hal_service_.isAidlPowerHalExist(); } bool isPowerHalConnected() { return power_hal_service_.isPowerHalConnected(); } bool isPowerHalExtConnected() { return power_hal_service_.isPowerHalExtConnected(); } @@ -136,10 +148,11 @@ class ThermalHelper { private: bool initializeSensorMap(const std::unordered_map<std::string, std::string> &path_map); bool initializeCoolingDevices(const std::unordered_map<std::string, std::string> &path_map); + bool isSubSensorValid(std::string_view sensor_data, const SensorFusionType sensor_fusion_type); void setMinTimeout(SensorInfo *sensor_info); void initializeTrip(const std::unordered_map<std::string, std::string> &path_map, std::set<std::string> *monitored_sensors, bool thermal_genl_enabled); - + void clearAllThrottling(); // For thermal_watcher_'s polling thread, return the sleep interval std::chrono::milliseconds thermalWatcherCallbackFunc( const std::set<std::string> &uevent_sensors); @@ -149,8 +162,13 @@ class ThermalHelper { const ThrottlingArray &hot_hysteresis, const ThrottlingArray &cold_hysteresis, ThrottlingSeverity prev_hot_severity, ThrottlingSeverity prev_cold_severity, float value) const; + // Read sensor data according to the type + bool readDataByType(std::string_view sensor_data, float *reading_value, + const SensorFusionType type, const bool force_no_cache, + std::map<std::string, float> *sensor_log_map); // Read temperature data according to thermal sensor's info - bool readThermalSensor(std::string_view sensor_name, float *temp, const bool force_sysfs); + bool readThermalSensor(std::string_view sensor_name, float *temp, const bool force_sysfs, + std::map<std::string, float> *sensor_log_map); bool connectToPowerHal(); void updateSupportedPowerHints(); void updateCoolingDevices(const std::vector<std::string> &cooling_devices_to_update); @@ -163,16 +181,16 @@ class ThermalHelper { const NotificationCallback cb_; std::unordered_map<std::string, CdevInfo> cooling_device_info_map_; std::unordered_map<std::string, SensorInfo> sensor_info_map_; - std::unordered_map<std::string, std::map<ThrottlingSeverity, ThrottlingSeverity>> + std::unordered_map<std::string, std::unordered_map<ThrottlingSeverity, ThrottlingSeverity>> supported_powerhint_map_; PowerHalService power_hal_service_; - + ThermalStatsHelper thermal_stats_helper_; mutable std::shared_mutex sensor_status_map_mutex_; std::unordered_map<std::string, SensorStatus> sensor_status_map_; }; } // namespace implementation -} // namespace V2_0 } // namespace thermal } // namespace hardware } // namespace android +} // namespace aidl diff --git a/thermal/utils/power_files.cpp b/thermal/utils/power_files.cpp index 3561e847..50cc5b62 100644 --- a/thermal/utils/power_files.cpp +++ b/thermal/utils/power_files.cpp @@ -1,6 +1,6 @@ /* - * Copyright (C) 2021 The Android Open Source Project + * Copyright (C) 2022 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. @@ -26,21 +26,21 @@ #include <dirent.h> #include <utils/Trace.h> +namespace aidl { namespace android { namespace hardware { namespace thermal { -namespace V2_0 { namespace implementation { constexpr std::string_view kDeviceType("iio:device"); constexpr std::string_view kIioRootDir("/sys/bus/iio/devices"); constexpr std::string_view kEnergyValueNode("energy_value"); -using android::base::ReadFileToString; -using android::base::StringPrintf; +using ::android::base::ReadFileToString; +using ::android::base::StringPrintf; -bool PowerFiles::registerPowerRailsToWatch(std::string_view config_path) { - if (!ParsePowerRailInfo(config_path, &power_rail_info_map_)) { +bool PowerFiles::registerPowerRailsToWatch(const Json::Value &config) { + if (!ParsePowerRailInfo(config, &power_rail_info_map_)) { LOG(ERROR) << "Failed to parse power rail info config"; return false; } @@ -159,7 +159,7 @@ bool PowerFiles::updateEnergyValues(void) { ATRACE_CALL(); for (const auto &path : energy_path_set_) { - if (!android::base::ReadFileToString(path, &deviceEnergyContent)) { + if (!::android::base::ReadFileToString(path, &deviceEnergyContent)) { LOG(ERROR) << "Failed to read energy content from " << path; return false; } else { @@ -336,7 +336,7 @@ bool PowerFiles::refreshPowerStatus(void) { } } // namespace implementation -} // namespace V2_0 } // namespace thermal } // namespace hardware } // namespace android +} // namespace aidl diff --git a/thermal/utils/power_files.h b/thermal/utils/power_files.h index 65c67584..bcf8e820 100644 --- a/thermal/utils/power_files.h +++ b/thermal/utils/power_files.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2021 The Android Open Source Project + * Copyright (C) 2022 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. @@ -27,13 +27,13 @@ #include "thermal_info.h" +namespace aidl { namespace android { namespace hardware { namespace thermal { -namespace V2_0 { namespace implementation { -using android::base::boot_clock; +using ::android::base::boot_clock; struct PowerSample { uint64_t energy_counter; @@ -55,7 +55,7 @@ class PowerFiles { // Disallow copy and assign. PowerFiles(const PowerFiles &) = delete; void operator=(const PowerFiles &) = delete; - bool registerPowerRailsToWatch(std::string_view config_path); + bool registerPowerRailsToWatch(const Json::Value &config); // Update the power data from ODPM sysfs bool refreshPowerStatus(void); // Get power status map @@ -89,7 +89,7 @@ class PowerFiles { }; } // namespace implementation -} // namespace V2_0 } // namespace thermal } // namespace hardware } // namespace android +} // namespace aidl diff --git a/thermal/utils/powerhal_helper.cpp b/thermal/utils/powerhal_helper.cpp index 515fa2d9..c40d2629 100644 --- a/thermal/utils/powerhal_helper.cpp +++ b/thermal/utils/powerhal_helper.cpp @@ -22,7 +22,6 @@ #include <android-base/stringprintf.h> #include <android-base/strings.h> #include <android/binder_manager.h> -#include <hidl/HidlTransportSupport.h> #include <iterator> #include <set> @@ -33,13 +32,13 @@ #include "thermal_info.h" #include "thermal_throttling.h" +namespace aidl { namespace android { namespace hardware { namespace thermal { -namespace V2_0 { namespace implementation { -using android::base::StringPrintf; +using ::android::base::StringPrintf; PowerHalService::PowerHalService() : power_hal_aidl_exist_(true), power_hal_aidl_(nullptr), power_hal_ext_aidl_(nullptr) { @@ -48,11 +47,14 @@ PowerHalService::PowerHalService() bool PowerHalService::connect() { std::lock_guard<std::mutex> lock(lock_); - if (!power_hal_aidl_exist_) + + if (!power_hal_aidl_exist_) { return false; + } - if (power_hal_aidl_ != nullptr) + if (power_hal_aidl_ && power_hal_ext_aidl_) { return true; + } const std::string kInstance = std::string(IPower::descriptor) + "/default"; ndk::SpAIBinder power_binder = ndk::SpAIBinder(AServiceManager_getService(kInstance.c_str())); @@ -90,14 +92,13 @@ bool PowerHalService::connect() { bool PowerHalService::isModeSupported(const std::string &type, const ThrottlingSeverity &t) { bool isSupported = false; - if (!isPowerHalConnected()) { + if (!connect()) { return false; } std::string power_hint = StringPrintf("THERMAL_%s_%s", type.c_str(), toString(t).c_str()); lock_.lock(); if (!power_hal_ext_aidl_->isModeSupported(power_hint, &isSupported).isOk()) { LOG(ERROR) << "Fail to check supported mode, Hint: " << power_hint; - power_hal_aidl_exist_ = false; power_hal_ext_aidl_ = nullptr; power_hal_aidl_ = nullptr; lock_.unlock(); @@ -108,27 +109,30 @@ bool PowerHalService::isModeSupported(const std::string &type, const ThrottlingS } void PowerHalService::setMode(const std::string &type, const ThrottlingSeverity &t, - const bool &enable) { - if (!isPowerHalConnected()) { + const bool &enable, const bool error_on_exit) { + if (!connect()) { return; } std::string power_hint = StringPrintf("THERMAL_%s_%s", type.c_str(), toString(t).c_str()); - LOG(INFO) << "Send Hint " << power_hint << " Enable: " << std::boolalpha << enable; + LOG(INFO) << (error_on_exit ? "Resend Hint " : "Send Hint ") << power_hint + << " Enable: " << std::boolalpha << enable; lock_.lock(); if (!power_hal_ext_aidl_->setMode(power_hint, enable).isOk()) { LOG(ERROR) << "Fail to set mode, Hint: " << power_hint; - power_hal_aidl_exist_ = false; power_hal_ext_aidl_ = nullptr; power_hal_aidl_ = nullptr; lock_.unlock(); + if (!error_on_exit) { + setMode(type, t, enable, true); + } return; } lock_.unlock(); } } // namespace implementation -} // namespace V2_0 } // namespace thermal } // namespace hardware } // namespace android +} // namespace aidl diff --git a/thermal/utils/powerhal_helper.h b/thermal/utils/powerhal_helper.h index 761e315c..0769aa23 100644 --- a/thermal/utils/powerhal_helper.h +++ b/thermal/utils/powerhal_helper.h @@ -17,8 +17,8 @@ #pragma once #include <aidl/android/hardware/power/IPower.h> +#include <aidl/android/hardware/thermal/ThrottlingSeverity.h> #include <aidl/google/hardware/power/extension/pixel/IPowerExt.h> -#include <android/hardware/thermal/2.0/IThermal.h> #include <queue> #include <shared_mutex> @@ -26,20 +26,15 @@ #include <unordered_map> #include <unordered_set> +namespace aidl { namespace android { namespace hardware { namespace thermal { -namespace V2_0 { namespace implementation { using ::aidl::android::hardware::power::IPower; using ::aidl::google::hardware::power::extension::pixel::IPowerExt; -using ::android::hardware::hidl_vec; -using ::android::hardware::thermal::V2_0::IThermal; -using Temperature_2_0 = ::android::hardware::thermal::V2_0::Temperature; -using ::android::hardware::thermal::V2_0::TemperatureThreshold; -using ::android::hardware::thermal::V2_0::ThrottlingSeverity; using CdevRequestStatus = std::unordered_map<std::string, int>; class PowerHalService { @@ -51,7 +46,8 @@ class PowerHalService { bool isModeSupported(const std::string &type, const ThrottlingSeverity &t); bool isPowerHalConnected() { return power_hal_aidl_ != nullptr; } bool isPowerHalExtConnected() { return power_hal_ext_aidl_ != nullptr; } - void setMode(const std::string &type, const ThrottlingSeverity &t, const bool &enable); + void setMode(const std::string &type, const ThrottlingSeverity &t, const bool &enable, + const bool error_on_exit = false); private: bool power_hal_aidl_exist_; @@ -61,7 +57,7 @@ class PowerHalService { }; } // namespace implementation -} // namespace V2_0 } // namespace thermal } // namespace hardware } // namespace android +} // namespace aidl diff --git a/thermal/utils/thermal_files.cpp b/thermal/utils/thermal_files.cpp index ff10d8b6..26aaf450 100644 --- a/thermal/utils/thermal_files.cpp +++ b/thermal/utils/thermal_files.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2021 The Android Open Source Project + * Copyright (C) 2022 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. @@ -27,13 +27,13 @@ #include <algorithm> #include <string_view> +namespace aidl { namespace android { namespace hardware { namespace thermal { -namespace V2_0 { namespace implementation { -using android::base::StringPrintf; +using ::android::base::StringPrintf; std::string ThermalFiles::getThermalFilePath(std::string_view thermal_name) const { auto sensor_itr = thermal_name_to_path_map_.find(thermal_name.data()); @@ -70,10 +70,10 @@ bool ThermalFiles::readThermalFile(std::string_view thermal_name, std::string *d bool ThermalFiles::writeCdevFile(std::string_view cdev_name, std::string_view data) { std::string file_path = - getThermalFilePath(android::base::StringPrintf("%s_%s", cdev_name.data(), "w")); + getThermalFilePath(::android::base::StringPrintf("%s_%s", cdev_name.data(), "w")); ATRACE_NAME(StringPrintf("ThermalFiles::writeCdevFile - %s", cdev_name.data()).c_str()); - if (!android::base::WriteStringToFile(data.data(), file_path)) { + if (!::android::base::WriteStringToFile(data.data(), file_path)) { PLOG(WARNING) << "Failed to write cdev: " << cdev_name << " to " << data.data(); return false; } @@ -82,7 +82,7 @@ bool ThermalFiles::writeCdevFile(std::string_view cdev_name, std::string_view da } } // namespace implementation -} // namespace V2_0 } // namespace thermal } // namespace hardware } // namespace android +} // namespace aidl diff --git a/thermal/utils/thermal_files.h b/thermal/utils/thermal_files.h index 59afba64..4b837809 100644 --- a/thermal/utils/thermal_files.h +++ b/thermal/utils/thermal_files.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2021 The Android Open Source Project + * Copyright (C) 2022 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. @@ -19,10 +19,10 @@ #include <string> #include <unordered_map> +namespace aidl { namespace android { namespace hardware { namespace thermal { -namespace V2_0 { namespace implementation { class ThermalFiles { @@ -47,7 +47,7 @@ class ThermalFiles { }; } // namespace implementation -} // namespace V2_0 } // namespace thermal } // namespace hardware } // namespace android +} // namespace aidl diff --git a/thermal/utils/thermal_info.cpp b/thermal/utils/thermal_info.cpp index f01d11be..c00bf63e 100644 --- a/thermal/utils/thermal_info.cpp +++ b/thermal/utils/thermal_info.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2018 The Android Open Source Project + * Copyright (C) 2022 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. @@ -20,31 +20,26 @@ #include <android-base/properties.h> #include <android-base/strings.h> #include <json/reader.h> -#include <json/value.h> #include <cmath> #include <unordered_set> +namespace aidl { namespace android { namespace hardware { namespace thermal { -namespace V2_0 { namespace implementation { constexpr std::string_view kPowerLinkDisabledProperty("vendor.disable.thermal.powerlink"); -using ::android::hardware::hidl_enum_range; -using ::android::hardware::thermal::V2_0::toString; -using TemperatureType_2_0 = ::android::hardware::thermal::V2_0::TemperatureType; - namespace { template <typename T> // Return false when failed parsing bool getTypeFromString(std::string_view str, T *out) { - auto types = hidl_enum_range<T>(); + auto types = ::ndk::enum_range<T>(); for (const auto &type : types) { - if (toString(type) == str) { + if (::aidl::android::hardware::thermal::toString(type) == str) { *out = type; return true; } @@ -136,24 +131,438 @@ bool getFloatFromJsonValues(const Json::Value &values, ThrottlingArray *out, boo } } // namespace -bool ParseSensorInfo(std::string_view config_path, - std::unordered_map<std::string, SensorInfo> *sensors_parsed) { +bool ParseThermalConfig(std::string_view config_path, Json::Value *config) { std::string json_doc; - if (!android::base::ReadFileToString(config_path.data(), &json_doc)) { + if (!::android::base::ReadFileToString(config_path.data(), &json_doc)) { LOG(ERROR) << "Failed to read JSON config from " << config_path; return false; } - Json::Value root; Json::CharReaderBuilder builder; std::unique_ptr<Json::CharReader> reader(builder.newCharReader()); std::string errorMessage; - - if (!reader->parse(&*json_doc.begin(), &*json_doc.end(), &root, &errorMessage)) { + if (!reader->parse(&*json_doc.begin(), &*json_doc.end(), config, &errorMessage)) { LOG(ERROR) << "Failed to parse JSON config: " << errorMessage; return false; } + return true; +} + +bool ParseVirtualSensorInfo(const std::string_view name, const Json::Value &sensor, + std::unique_ptr<VirtualSensorInfo> *virtual_sensor_info) { + if (sensor["VirtualSensor"].empty() || !sensor["VirtualSensor"].isBool()) { + LOG(INFO) << "Failed to read Sensor[" << name << "]'s VirtualSensor"; + return true; + } + bool is_virtual_sensor = sensor["VirtualSensor"].asBool(); + LOG(INFO) << "Sensor[" << name << "]'s' VirtualSensor: " << is_virtual_sensor; + if (!is_virtual_sensor) { + return true; + } + float offset = 0; + std::vector<std::string> linked_sensors; + std::vector<SensorFusionType> linked_sensors_type; + std::vector<std::string> trigger_sensors; + std::vector<float> coefficients; + FormulaOption formula = FormulaOption::COUNT_THRESHOLD; + + Json::Value values = sensor["Combination"]; + if (values.size()) { + linked_sensors.reserve(values.size()); + for (Json::Value::ArrayIndex j = 0; j < values.size(); ++j) { + linked_sensors.emplace_back(values[j].asString()); + LOG(INFO) << "Sensor[" << name << "]'s Combination[" << j << "]: " << linked_sensors[j]; + } + } else { + LOG(ERROR) << "Sensor[" << name << "] has no Combination setting"; + return false; + } + + values = sensor["CombinationType"]; + if (!values.size()) { + linked_sensors_type.reserve(linked_sensors.size()); + for (size_t j = 0; j < linked_sensors.size(); ++j) { + linked_sensors_type.emplace_back(SensorFusionType::SENSOR); + } + } else if (values.size() != linked_sensors.size()) { + LOG(ERROR) << "Sensor[" << name << "] has invalid CombinationType size"; + return false; + } else { + for (Json::Value::ArrayIndex j = 0; j < values.size(); ++j) { + if (values[j].asString().compare("SENSOR") == 0) { + linked_sensors_type.emplace_back(SensorFusionType::SENSOR); + } else if (values[j].asString().compare("ODPM") == 0) { + linked_sensors_type.emplace_back(SensorFusionType::ODPM); + } else { + LOG(ERROR) << "Sensor[" << name << "] has invalid CombinationType settings " + << values[j].asString(); + return false; + } + LOG(INFO) << "Sensor[" << name << "]'s CombinationType[" << j + << "]: " << linked_sensors_type[j]; + } + } + + values = sensor["Coefficient"]; + if (values.size()) { + coefficients.reserve(values.size()); + for (Json::Value::ArrayIndex j = 0; j < values.size(); ++j) { + coefficients.emplace_back(getFloatFromValue(values[j])); + LOG(INFO) << "Sensor[" << name << "]'s coefficient[" << j << "]: " << coefficients[j]; + } + } else { + LOG(ERROR) << "Sensor[" << name << "] has no Coefficient setting"; + return false; + } + if (linked_sensors.size() != coefficients.size()) { + LOG(ERROR) << "Sensor[" << name << "] has invalid Coefficient size"; + return false; + } + if (!sensor["Offset"].empty()) { + offset = sensor["Offset"].asFloat(); + } + + values = sensor["TriggerSensor"]; + if (!values.empty()) { + if (values.isString()) { + trigger_sensors.emplace_back(values.asString()); + LOG(INFO) << "Sensor[" << name << "]'s TriggerSensor: " << values.asString(); + } else if (values.size()) { + trigger_sensors.reserve(values.size()); + for (Json::Value::ArrayIndex j = 0; j < values.size(); ++j) { + if (!values[j].isString()) { + LOG(ERROR) << name << " TriggerSensor should be an array of string"; + return false; + } + trigger_sensors.emplace_back(values[j].asString()); + LOG(INFO) << "Sensor[" << name << "]'s TriggerSensor[" << j + << "]: " << trigger_sensors[j]; + } + } else { + LOG(ERROR) << "Sensor[" << name << "]'s TriggerSensor should be a string"; + return false; + } + } + + if (sensor["Formula"].asString().compare("COUNT_THRESHOLD") == 0) { + formula = FormulaOption::COUNT_THRESHOLD; + } else if (sensor["Formula"].asString().compare("WEIGHTED_AVG") == 0) { + formula = FormulaOption::WEIGHTED_AVG; + } else if (sensor["Formula"].asString().compare("MAXIMUM") == 0) { + formula = FormulaOption::MAXIMUM; + } else if (sensor["Formula"].asString().compare("MINIMUM") == 0) { + formula = FormulaOption::MINIMUM; + } else { + LOG(ERROR) << "Sensor[" << name << "]'s Formula is invalid"; + return false; + } + virtual_sensor_info->reset(new VirtualSensorInfo{ + linked_sensors, linked_sensors_type, coefficients, offset, trigger_sensors, formula}); + return true; +} + +bool ParseBindedCdevInfo(const Json::Value &values, + std::unordered_map<std::string, BindedCdevInfo> *binded_cdev_info_map, + const bool support_pid, bool *support_hard_limit) { + for (Json::Value::ArrayIndex j = 0; j < values.size(); ++j) { + Json::Value sub_values; + const std::string &cdev_name = values[j]["CdevRequest"].asString(); + ThrottlingArray cdev_weight_for_pid; + cdev_weight_for_pid.fill(NAN); + CdevArray cdev_ceiling; + cdev_ceiling.fill(std::numeric_limits<int>::max()); + int max_release_step = std::numeric_limits<int>::max(); + int max_throttle_step = std::numeric_limits<int>::max(); + if (support_pid) { + if (!values[j]["CdevWeightForPID"].empty()) { + LOG(INFO) << "Star to parse " << cdev_name << "'s CdevWeightForPID"; + if (!getFloatFromJsonValues(values[j]["CdevWeightForPID"], &cdev_weight_for_pid, + false, false)) { + LOG(ERROR) << "Failed to parse CdevWeightForPID"; + binded_cdev_info_map->clear(); + return false; + } + } + if (!values[j]["CdevCeiling"].empty()) { + LOG(INFO) << "Start to parse CdevCeiling: " << cdev_name; + if (!getIntFromJsonValues(values[j]["CdevCeiling"], &cdev_ceiling, false, false)) { + LOG(ERROR) << "Failed to parse CdevCeiling"; + binded_cdev_info_map->clear(); + return false; + } + } + + if (!values[j]["MaxReleaseStep"].empty()) { + max_release_step = getIntFromValue(values[j]["MaxReleaseStep"]); + if (max_release_step < 0) { + LOG(ERROR) << cdev_name << " MaxReleaseStep: " << max_release_step; + binded_cdev_info_map->clear(); + return false; + } else { + LOG(INFO) << cdev_name << " MaxReleaseStep: " << max_release_step; + } + } + if (!values[j]["MaxThrottleStep"].empty()) { + max_throttle_step = getIntFromValue(values[j]["MaxThrottleStep"]); + if (max_throttle_step < 0) { + LOG(ERROR) << cdev_name << " MaxThrottleStep: " << max_throttle_step; + binded_cdev_info_map->clear(); + return false; + } else { + LOG(INFO) << cdev_name << " MaxThrottleStep: " << max_throttle_step; + } + } + } + CdevArray limit_info; + limit_info.fill(0); + ThrottlingArray power_thresholds; + power_thresholds.fill(NAN); + ReleaseLogic release_logic = ReleaseLogic::NONE; + + sub_values = values[j]["LimitInfo"]; + if (sub_values.size()) { + LOG(INFO) << "Start to parse LimitInfo: " << cdev_name; + if (!getIntFromJsonValues(sub_values, &limit_info, false, false)) { + LOG(ERROR) << "Failed to parse LimitInfo"; + binded_cdev_info_map->clear(); + return false; + } + *support_hard_limit = true; + } + // Parse linked power info + std::string power_rail; + bool high_power_check = false; + bool throttling_with_power_link = false; + CdevArray cdev_floor_with_power_link; + cdev_floor_with_power_link.fill(0); + + const bool power_link_disabled = + ::android::base::GetBoolProperty(kPowerLinkDisabledProperty.data(), false); + if (!power_link_disabled) { + power_rail = values[j]["BindedPowerRail"].asString(); + + if (values[j]["HighPowerCheck"].asBool()) { + high_power_check = true; + } + LOG(INFO) << "Highpowercheck: " << std::boolalpha << high_power_check; + + if (values[j]["ThrottlingWithPowerLink"].asBool()) { + throttling_with_power_link = true; + } + LOG(INFO) << "ThrottlingwithPowerLink: " << std::boolalpha + << throttling_with_power_link; + + sub_values = values[j]["CdevFloorWithPowerLink"]; + if (sub_values.size()) { + LOG(INFO) << "Start to parse " << cdev_name << "'s CdevFloorWithPowerLink"; + if (!getIntFromJsonValues(sub_values, &cdev_floor_with_power_link, false, false)) { + LOG(ERROR) << "Failed to parse CdevFloor"; + binded_cdev_info_map->clear(); + return false; + } + } + sub_values = values[j]["PowerThreshold"]; + if (sub_values.size()) { + LOG(INFO) << "Start to parse " << cdev_name << "'s PowerThreshold"; + if (!getFloatFromJsonValues(sub_values, &power_thresholds, false, false)) { + LOG(ERROR) << "Failed to parse power thresholds"; + binded_cdev_info_map->clear(); + return false; + } + if (values[j]["ReleaseLogic"].asString() == "INCREASE") { + release_logic = ReleaseLogic::INCREASE; + LOG(INFO) << "Release logic: INCREASE"; + } else if (values[j]["ReleaseLogic"].asString() == "DECREASE") { + release_logic = ReleaseLogic::DECREASE; + LOG(INFO) << "Release logic: DECREASE"; + } else if (values[j]["ReleaseLogic"].asString() == "STEPWISE") { + release_logic = ReleaseLogic::STEPWISE; + LOG(INFO) << "Release logic: STEPWISE"; + } else if (values[j]["ReleaseLogic"].asString() == "RELEASE_TO_FLOOR") { + release_logic = ReleaseLogic::RELEASE_TO_FLOOR; + LOG(INFO) << "Release logic: RELEASE_TO_FLOOR"; + } else { + LOG(ERROR) << "Release logic is invalid"; + binded_cdev_info_map->clear(); + return false; + } + } + } + + (*binded_cdev_info_map)[cdev_name] = { + .limit_info = limit_info, + .power_thresholds = power_thresholds, + .release_logic = release_logic, + .high_power_check = high_power_check, + .throttling_with_power_link = throttling_with_power_link, + .cdev_weight_for_pid = cdev_weight_for_pid, + .cdev_ceiling = cdev_ceiling, + .max_release_step = max_release_step, + .max_throttle_step = max_throttle_step, + .cdev_floor_with_power_link = cdev_floor_with_power_link, + .power_rail = power_rail, + }; + } + return true; +} + +bool ParseSensorThrottlingInfo(const std::string_view name, const Json::Value &sensor, + bool *support_throttling, + std::shared_ptr<ThrottlingInfo> *throttling_info) { + std::array<float, kThrottlingSeverityCount> k_po; + k_po.fill(0.0); + std::array<float, kThrottlingSeverityCount> k_pu; + k_pu.fill(0.0); + std::array<float, kThrottlingSeverityCount> k_i; + k_i.fill(0.0); + std::array<float, kThrottlingSeverityCount> k_d; + k_d.fill(0.0); + std::array<float, kThrottlingSeverityCount> i_max; + i_max.fill(NAN); + std::array<float, kThrottlingSeverityCount> max_alloc_power; + max_alloc_power.fill(NAN); + std::array<float, kThrottlingSeverityCount> min_alloc_power; + min_alloc_power.fill(NAN); + std::array<float, kThrottlingSeverityCount> s_power; + s_power.fill(NAN); + std::array<float, kThrottlingSeverityCount> i_cutoff; + i_cutoff.fill(NAN); + float i_default = 0.0; + int tran_cycle = 0; + bool support_pid = false; + bool support_hard_limit = false; + + // Parse PID parameters + if (!sensor["PIDInfo"].empty()) { + LOG(INFO) << "Start to parse" + << " Sensor[" << name << "]'s K_Po"; + if (sensor["PIDInfo"]["K_Po"].empty() || + !getFloatFromJsonValues(sensor["PIDInfo"]["K_Po"], &k_po, false, false)) { + LOG(ERROR) << "Sensor[" << name << "]: Failed to parse K_Po"; + return false; + } + LOG(INFO) << "Start to parse" + << " Sensor[" << name << "]'s K_Pu"; + if (sensor["PIDInfo"]["K_Pu"].empty() || + !getFloatFromJsonValues(sensor["PIDInfo"]["K_Pu"], &k_pu, false, false)) { + LOG(ERROR) << "Sensor[" << name << "]: Failed to parse K_Pu"; + return false; + } + LOG(INFO) << "Start to parse" + << " Sensor[" << name << "]'s K_I"; + if (sensor["PIDInfo"]["K_I"].empty() || + !getFloatFromJsonValues(sensor["PIDInfo"]["K_I"], &k_i, false, false)) { + LOG(ERROR) << "Sensor[" << name << "]: Failed to parse K_I"; + return false; + } + LOG(INFO) << "Start to parse" + << " Sensor[" << name << "]'s K_D"; + if (sensor["PIDInfo"]["K_D"].empty() || + !getFloatFromJsonValues(sensor["PIDInfo"]["K_D"], &k_d, false, false)) { + LOG(ERROR) << "Sensor[" << name << "]: Failed to parse K_D"; + return false; + } + LOG(INFO) << "Start to parse" + << " Sensor[" << name << "]'s I_Max"; + if (sensor["PIDInfo"]["I_Max"].empty() || + !getFloatFromJsonValues(sensor["PIDInfo"]["I_Max"], &i_max, false, false)) { + LOG(ERROR) << "Sensor[" << name << "]: Failed to parse I_Max"; + return false; + } + LOG(INFO) << "Start to parse" + << " Sensor[" << name << "]'s MaxAllocPower"; + if (sensor["PIDInfo"]["MaxAllocPower"].empty() || + !getFloatFromJsonValues(sensor["PIDInfo"]["MaxAllocPower"], &max_alloc_power, false, + true)) { + LOG(ERROR) << "Sensor[" << name << "]: Failed to parse MaxAllocPower"; + return false; + } + LOG(INFO) << "Start to parse" + << " Sensor[" << name << "]'s MinAllocPower"; + if (sensor["PIDInfo"]["MinAllocPower"].empty() || + !getFloatFromJsonValues(sensor["PIDInfo"]["MinAllocPower"], &min_alloc_power, false, + true)) { + LOG(ERROR) << "Sensor[" << name << "]: Failed to parse MinAllocPower"; + return false; + } + LOG(INFO) << "Start to parse Sensor[" << name << "]'s S_Power"; + if (sensor["PIDInfo"]["S_Power"].empty() || + !getFloatFromJsonValues(sensor["PIDInfo"]["S_Power"], &s_power, false, true)) { + LOG(ERROR) << "Sensor[" << name << "]: Failed to parse S_Power"; + return false; + } + LOG(INFO) << "Start to parse Sensor[" << name << "]'s I_Cutoff"; + if (sensor["PIDInfo"]["I_Cutoff"].empty() || + !getFloatFromJsonValues(sensor["PIDInfo"]["I_Cutoff"], &i_cutoff, false, false)) { + LOG(ERROR) << "Sensor[" << name << "]: Failed to parse I_Cutoff"; + return false; + } + i_default = getFloatFromValue(sensor["PIDInfo"]["I_Default"]); + LOG(INFO) << "Sensor[" << name << "]'s I_Default: " << i_default; + + tran_cycle = getFloatFromValue(sensor["PIDInfo"]["TranCycle"]); + LOG(INFO) << "Sensor[" << name << "]'s TranCycle: " << tran_cycle; + + // Confirm we have at least one valid PID combination + bool valid_pid_combination = false; + for (Json::Value::ArrayIndex j = 0; j < kThrottlingSeverityCount; ++j) { + if (!std::isnan(s_power[j])) { + if (std::isnan(k_po[j]) || std::isnan(k_pu[j]) || std::isnan(k_i[j]) || + std::isnan(k_d[j]) || std::isnan(i_max[j]) || std::isnan(max_alloc_power[j]) || + std::isnan(min_alloc_power[j]) || std::isnan(i_cutoff[j])) { + valid_pid_combination = false; + break; + } else { + valid_pid_combination = true; + } + } + } + if (!valid_pid_combination) { + LOG(ERROR) << "Sensor[" << name << "]: Invalid PID parameters combinations"; + return false; + } else { + support_pid = true; + } + } + + // Parse binded cooling device + std::unordered_map<std::string, BindedCdevInfo> binded_cdev_info_map; + if (!ParseBindedCdevInfo(sensor["BindedCdevInfo"], &binded_cdev_info_map, support_pid, + &support_hard_limit)) { + LOG(ERROR) << "Sensor[" << name << "]: failed to parse BindedCdevInfo"; + return false; + } - Json::Value sensors = root["Sensors"]; + std::unordered_map<std::string, ThrottlingArray> excluded_power_info_map; + Json::Value values = sensor["ExcludedPowerInfo"]; + for (Json::Value::ArrayIndex j = 0; j < values.size(); ++j) { + Json::Value sub_values; + const std::string &power_rail = values[j]["PowerRail"].asString(); + if (power_rail.empty()) { + LOG(ERROR) << "Sensor[" << name << "] failed to parse excluded PowerRail"; + return false; + } + ThrottlingArray power_weight; + power_weight.fill(1); + if (!values[j]["PowerWeight"].empty()) { + LOG(INFO) << "Sensor[" << name << "]: Start to parse " << power_rail + << "'s PowerWeight"; + if (!getFloatFromJsonValues(values[j]["PowerWeight"], &power_weight, false, false)) { + LOG(ERROR) << "Failed to parse PowerWeight"; + return false; + } + } + excluded_power_info_map[power_rail] = power_weight; + } + throttling_info->reset(new ThrottlingInfo{ + k_po, k_pu, k_i, k_d, i_max, max_alloc_power, min_alloc_power, s_power, i_cutoff, + i_default, tran_cycle, excluded_power_info_map, binded_cdev_info_map}); + *support_throttling = support_pid | support_hard_limit; + return true; +} + +bool ParseSensorInfo(const Json::Value &config, + std::unordered_map<std::string, SensorInfo> *sensors_parsed) { + Json::Value sensors = config["Sensors"]; std::size_t total_parsed = 0; std::unordered_set<std::string> sensors_name_parsed; @@ -161,8 +570,7 @@ bool ParseSensorInfo(std::string_view config_path, const std::string &name = sensors[i]["Name"].asString(); LOG(INFO) << "Sensor[" << i << "]'s Name: " << name; if (name.empty()) { - LOG(ERROR) << "Failed to read " - << "Sensor[" << i << "]'s Name"; + LOG(ERROR) << "Failed to read Sensor[" << i << "]'s Name"; sensors_parsed->clear(); return false; } @@ -176,20 +584,19 @@ bool ParseSensorInfo(std::string_view config_path, std::string sensor_type_str = sensors[i]["Type"].asString(); LOG(INFO) << "Sensor[" << name << "]'s Type: " << sensor_type_str; - TemperatureType_2_0 sensor_type; + TemperatureType sensor_type; if (!getTypeFromString(sensor_type_str, &sensor_type)) { - LOG(ERROR) << "Invalid " - << "Sensor[" << name << "]'s Type: " << sensor_type_str; + LOG(ERROR) << "Invalid Sensor[" << name << "]'s Type: " << sensor_type_str; sensors_parsed->clear(); return false; } bool send_cb = false; - if (sensors[i]["Monitor"].empty() || !sensors[i]["Monitor"].isBool()) { - LOG(INFO) << "Failed to read Sensor[" << name << "]'s Monitor, set to 'false'"; - } else if (sensors[i]["Monitor"].asBool()) { - send_cb = true; + if (!sensors[i]["Monitor"].empty() && sensors[i]["Monitor"].isBool()) { + send_cb = sensors[i]["Monitor"].asBool(); + } else if (!sensors[i]["SendCallback"].empty() && sensors[i]["SendCallback"].isBool()) { + send_cb = sensors[i]["SendCallback"].asBool(); } LOG(INFO) << "Sensor[" << name << "]'s SendCallback: " << std::boolalpha << send_cb << std::noboolalpha; @@ -220,24 +627,12 @@ bool ParseSensorInfo(std::string_view config_path, hot_hysteresis.fill(0.0); std::array<float, kThrottlingSeverityCount> cold_hysteresis; cold_hysteresis.fill(0.0); - std::vector<std::string> linked_sensors; - std::vector<float> coefficients; - float offset = 0; - std::string trigger_sensor; - FormulaOption formula = FormulaOption::COUNT_THRESHOLD; - bool is_virtual_sensor = false; - if (sensors[i]["VirtualSensor"].empty() || !sensors[i]["VirtualSensor"].isBool()) { - LOG(INFO) << "Failed to read Sensor[" << name << "]'s VirtualSensor, set to 'false'"; - } else { - is_virtual_sensor = sensors[i]["VirtualSensor"].asBool(); - } Json::Value values = sensors[i]["HotThreshold"]; if (!values.size()) { LOG(INFO) << "Sensor[" << name << "]'s HotThreshold, default all to NAN"; } else if (values.size() != kThrottlingSeverityCount) { - LOG(ERROR) << "Invalid " - << "Sensor[" << name << "]'s HotThreshold count:" << values.size(); + LOG(ERROR) << "Invalid Sensor[" << name << "]'s HotThreshold count:" << values.size(); sensors_parsed->clear(); return false; } else { @@ -263,16 +658,15 @@ bool ParseSensorInfo(std::string_view config_path, if (!values.size()) { LOG(INFO) << "Sensor[" << name << "]'s HotHysteresis, default all to 0.0"; } else if (values.size() != kThrottlingSeverityCount) { - LOG(ERROR) << "Invalid " - << "Sensor[" << name << "]'s HotHysteresis, count:" << values.size(); + LOG(ERROR) << "Invalid Sensor[" << name << "]'s HotHysteresis, count:" << values.size(); sensors_parsed->clear(); return false; } else { for (Json::Value::ArrayIndex j = 0; j < kThrottlingSeverityCount; ++j) { hot_hysteresis[j] = getFloatFromValue(values[j]); if (std::isnan(hot_hysteresis[j])) { - LOG(ERROR) << "Invalid " - << "Sensor[" << name << "]'s HotHysteresis: " << hot_hysteresis[j]; + LOG(ERROR) << "Invalid Sensor[" << name + << "]'s HotHysteresis: " << hot_hysteresis[j]; sensors_parsed->clear(); return false; } @@ -303,8 +697,7 @@ bool ParseSensorInfo(std::string_view config_path, if (!values.size()) { LOG(INFO) << "Sensor[" << name << "]'s ColdThreshold, default all to NAN"; } else if (values.size() != kThrottlingSeverityCount) { - LOG(ERROR) << "Invalid " - << "Sensor[" << name << "]'s ColdThreshold count:" << values.size(); + LOG(ERROR) << "Invalid Sensor[" << name << "]'s ColdThreshold count:" << values.size(); sensors_parsed->clear(); return false; } else { @@ -330,16 +723,15 @@ bool ParseSensorInfo(std::string_view config_path, if (!values.size()) { LOG(INFO) << "Sensor[" << name << "]'s ColdHysteresis, default all to 0.0"; } else if (values.size() != kThrottlingSeverityCount) { - LOG(ERROR) << "Invalid " - << "Sensor[" << name << "]'s ColdHysteresis count:" << values.size(); + LOG(ERROR) << "Invalid Sensor[" << name << "]'s ColdHysteresis count:" << values.size(); sensors_parsed->clear(); return false; } else { for (Json::Value::ArrayIndex j = 0; j < kThrottlingSeverityCount; ++j) { cold_hysteresis[j] = getFloatFromValue(values[j]); if (std::isnan(cold_hysteresis[j])) { - LOG(ERROR) << "Invalid " - << "Sensor[" << name << "]'s ColdHysteresis: " << cold_hysteresis[j]; + LOG(ERROR) << "Invalid Sensor[" << name + << "]'s ColdHysteresis: " << cold_hysteresis[j]; sensors_parsed->clear(); return false; } @@ -366,62 +758,6 @@ bool ParseSensorInfo(std::string_view config_path, } } - if (is_virtual_sensor) { - values = sensors[i]["Combination"]; - if (values.size()) { - linked_sensors.reserve(values.size()); - for (Json::Value::ArrayIndex j = 0; j < values.size(); ++j) { - linked_sensors.emplace_back(values[j].asString()); - LOG(INFO) << "Sensor[" << name << "]'s combination[" << j - << "]: " << linked_sensors[j]; - } - } else { - LOG(ERROR) << "Sensor[" << name << "] has no combination setting"; - sensors_parsed->clear(); - return false; - } - - values = sensors[i]["Coefficient"]; - if (values.size()) { - coefficients.reserve(values.size()); - for (Json::Value::ArrayIndex j = 0; j < values.size(); ++j) { - coefficients.emplace_back(getFloatFromValue(values[j])); - LOG(INFO) << "Sensor[" << name << "]'s coefficient[" << j - << "]: " << coefficients[j]; - } - } else { - LOG(ERROR) << "Sensor[" << name << "] has no coefficient setting"; - sensors_parsed->clear(); - return false; - } - - if (linked_sensors.size() != coefficients.size()) { - LOG(ERROR) << "Sensor[" << name - << "]'s combination size is not matched with coefficient size"; - sensors_parsed->clear(); - return false; - } - - if (!sensors[i]["Offset"].empty()) { - offset = sensors[i]["Offset"].asFloat(); - } - - trigger_sensor = sensors[i]["TriggerSensor"].asString(); - if (sensors[i]["Formula"].asString().compare("COUNT_THRESHOLD") == 0) { - formula = FormulaOption::COUNT_THRESHOLD; - } else if (sensors[i]["Formula"].asString().compare("WEIGHTED_AVG") == 0) { - formula = FormulaOption::WEIGHTED_AVG; - } else if (sensors[i]["Formula"].asString().compare("MAXIMUM") == 0) { - formula = FormulaOption::MAXIMUM; - } else if (sensors[i]["Formula"].asString().compare("MINIMUM") == 0) { - formula = FormulaOption::MINIMUM; - } else { - LOG(ERROR) << "Sensor[" << name << "]'s Formula is invalid"; - sensors_parsed->clear(); - return false; - } - } - std::string temp_path; if (!sensors[i]["TempPath"].empty()) { temp_path = sensors[i]["TempPath"].asString(); @@ -461,337 +797,29 @@ bool ParseSensorInfo(std::string_view config_path, } LOG(INFO) << "Sensor[" << name << "]'s Time resolution: " << time_resolution.count(); - bool support_pid = false; - std::array<float, kThrottlingSeverityCount> k_po; - k_po.fill(0.0); - std::array<float, kThrottlingSeverityCount> k_pu; - k_pu.fill(0.0); - std::array<float, kThrottlingSeverityCount> k_i; - k_i.fill(0.0); - std::array<float, kThrottlingSeverityCount> k_d; - k_d.fill(0.0); - std::array<float, kThrottlingSeverityCount> i_max; - i_max.fill(NAN); - std::array<float, kThrottlingSeverityCount> max_alloc_power; - max_alloc_power.fill(NAN); - std::array<float, kThrottlingSeverityCount> min_alloc_power; - min_alloc_power.fill(NAN); - std::array<float, kThrottlingSeverityCount> s_power; - s_power.fill(NAN); - std::array<float, kThrottlingSeverityCount> i_cutoff; - i_cutoff.fill(NAN); - float i_default = 0.0; - int tran_cycle = 0; - - // Parse PID parameters - if (!sensors[i]["PIDInfo"].empty()) { - LOG(INFO) << "Start to parse" - << " Sensor[" << name << "]'s K_Po"; - if (sensors[i]["PIDInfo"]["K_Po"].empty() || - !getFloatFromJsonValues(sensors[i]["PIDInfo"]["K_Po"], &k_po, false, false)) { - LOG(ERROR) << "Sensor[" << name << "]: Failed to parse K_Po"; - sensors_parsed->clear(); - return false; - } - LOG(INFO) << "Start to parse" - << " Sensor[" << name << "]'s K_Pu"; - if (sensors[i]["PIDInfo"]["K_Pu"].empty() || - !getFloatFromJsonValues(sensors[i]["PIDInfo"]["K_Pu"], &k_pu, false, false)) { - LOG(ERROR) << "Sensor[" << name << "]: Failed to parse K_Pu"; - sensors_parsed->clear(); - return false; - } - LOG(INFO) << "Start to parse" - << " Sensor[" << name << "]'s K_I"; - if (sensors[i]["PIDInfo"]["K_I"].empty() || - !getFloatFromJsonValues(sensors[i]["PIDInfo"]["K_I"], &k_i, false, false)) { - LOG(ERROR) << "Sensor[" << name << "]: Failed to parse K_I"; - sensors_parsed->clear(); - return false; - } - LOG(INFO) << "Start to parse" - << " Sensor[" << name << "]'s K_D"; - if (sensors[i]["PIDInfo"]["K_D"].empty() || - !getFloatFromJsonValues(sensors[i]["PIDInfo"]["K_D"], &k_d, false, false)) { - LOG(ERROR) << "Sensor[" << name << "]: Failed to parse K_D"; - sensors_parsed->clear(); - return false; - } - LOG(INFO) << "Start to parse" - << " Sensor[" << name << "]'s I_Max"; - if (sensors[i]["PIDInfo"]["I_Max"].empty() || - !getFloatFromJsonValues(sensors[i]["PIDInfo"]["I_Max"], &i_max, false, false)) { - LOG(ERROR) << "Sensor[" << name << "]: Failed to parse I_Max"; - sensors_parsed->clear(); - return false; - } - LOG(INFO) << "Start to parse" - << " Sensor[" << name << "]'s MaxAllocPower"; - if (sensors[i]["PIDInfo"]["MaxAllocPower"].empty() || - !getFloatFromJsonValues(sensors[i]["PIDInfo"]["MaxAllocPower"], &max_alloc_power, - false, true)) { - LOG(ERROR) << "Sensor[" << name << "]: Failed to parse MaxAllocPower"; - sensors_parsed->clear(); - return false; - } - LOG(INFO) << "Start to parse" - << " Sensor[" << name << "]'s MinAllocPower"; - if (sensors[i]["PIDInfo"]["MinAllocPower"].empty() || - !getFloatFromJsonValues(sensors[i]["PIDInfo"]["MinAllocPower"], &min_alloc_power, - false, true)) { - LOG(ERROR) << "Sensor[" << name << "]: Failed to parse MinAllocPower"; - sensors_parsed->clear(); - return false; - } - LOG(INFO) << "Start to parse" - << " Sensor[" << name << "]'s S_Power"; - if (sensors[i]["PIDInfo"]["S_Power"].empty() || - !getFloatFromJsonValues(sensors[i]["PIDInfo"]["S_Power"], &s_power, false, true)) { - LOG(ERROR) << "Sensor[" << name << "]: Failed to parse S_Power"; - sensors_parsed->clear(); - return false; - } - LOG(INFO) << "Start to parse" - << " Sensor[" << name << "]'s I_Cutoff"; - if (sensors[i]["PIDInfo"]["I_Cutoff"].empty() || - !getFloatFromJsonValues(sensors[i]["PIDInfo"]["I_Cutoff"], &i_cutoff, false, - false)) { - LOG(ERROR) << "Sensor[" << name << "]: Failed to parse I_Cutoff"; - sensors_parsed->clear(); - return false; - } - LOG(INFO) << "Start to parse" - << " Sensor[" << name << "]'s I_Default"; - i_default = getFloatFromValue(sensors[i]["PIDInfo"]["I_Default"]); - LOG(INFO) << "Sensor[" << name << "]'s I_Default: " << i_default; - - LOG(INFO) << "Start to parse" - << " Sensor[" << name << "]'s TranCycle"; - tran_cycle = getFloatFromValue(sensors[i]["PIDInfo"]["TranCycle"]); - LOG(INFO) << "Sensor[" << name << "]'s TranCycle: " << tran_cycle; - - // Confirm we have at least one valid PID combination - bool valid_pid_combination = false; - for (Json::Value::ArrayIndex j = 0; j < kThrottlingSeverityCount; ++j) { - if (!std::isnan(s_power[j])) { - if (std::isnan(k_po[j]) || std::isnan(k_pu[j]) || std::isnan(k_i[j]) || - std::isnan(k_d[j]) || std::isnan(i_max[j]) || - std::isnan(max_alloc_power[j]) || std::isnan(min_alloc_power[j]) || - std::isnan(i_cutoff[j])) { - valid_pid_combination = false; - break; - } else { - valid_pid_combination = true; - } - } - } - if (!valid_pid_combination) { - LOG(ERROR) << "Sensor[" << name << "]: Invalid PID parameters combinations"; - sensors_parsed->clear(); - return false; - } else { - support_pid = true; - } - } - - // Parse binded cooling device - bool support_hard_limit = false; - std::unordered_map<std::string, BindedCdevInfo> binded_cdev_info_map; - values = sensors[i]["BindedCdevInfo"]; - for (Json::Value::ArrayIndex j = 0; j < values.size(); ++j) { - Json::Value sub_values; - const std::string &cdev_name = values[j]["CdevRequest"].asString(); - ThrottlingArray cdev_weight_for_pid; - cdev_weight_for_pid.fill(NAN); - CdevArray cdev_ceiling; - cdev_ceiling.fill(std::numeric_limits<int>::max()); - int max_release_step = std::numeric_limits<int>::max(); - int max_throttle_step = std::numeric_limits<int>::max(); - if (support_pid) { - if (!values[j]["CdevWeightForPID"].empty()) { - LOG(INFO) << "Sensor[" << name << "]: Star to parse " << cdev_name - << "'s CdevWeightForPID"; - if (!getFloatFromJsonValues(values[j]["CdevWeightForPID"], &cdev_weight_for_pid, - false, false)) { - LOG(ERROR) << "Failed to parse CdevWeightForPID"; - sensors_parsed->clear(); - return false; - } - } - if (!values[j]["CdevCeiling"].empty()) { - LOG(INFO) << "Sensor[" << name - << "]: Start to parse CdevCeiling: " << cdev_name; - if (!getIntFromJsonValues(values[j]["CdevCeiling"], &cdev_ceiling, false, - false)) { - LOG(ERROR) << "Failed to parse CdevCeiling"; - sensors_parsed->clear(); - return false; - } - } - if (!values[j]["MaxReleaseStep"].empty()) { - max_release_step = getIntFromValue(values[j]["MaxReleaseStep"]); - if (max_release_step < 0) { - LOG(ERROR) << "Sensor[" << name << "]'s " << cdev_name - << " MaxReleaseStep: " << max_release_step; - sensors_parsed->clear(); - return false; - } else { - LOG(INFO) << "Sensor[" << name << "]'s " << cdev_name - << " MaxReleaseStep: " << max_release_step; - } - } - if (!values[j]["MaxThrottleStep"].empty()) { - max_throttle_step = getIntFromValue(values[j]["MaxThrottleStep"]); - if (max_throttle_step < 0) { - LOG(ERROR) << "Sensor[" << name << "]'s " << cdev_name - << " MaxThrottleStep: " << max_throttle_step; - sensors_parsed->clear(); - return false; - } else { - LOG(INFO) << "Sensor[" << name << "]'s " << cdev_name - << " MaxThrottleStep: " << max_throttle_step; - } - } - } - CdevArray limit_info; - limit_info.fill(0); - ThrottlingArray power_thresholds; - power_thresholds.fill(NAN); - - ReleaseLogic release_logic = ReleaseLogic::NONE; - - sub_values = values[j]["LimitInfo"]; - if (sub_values.size()) { - LOG(INFO) << "Sensor[" << name << "]: Start to parse LimitInfo: " << cdev_name; - if (!getIntFromJsonValues(sub_values, &limit_info, false, false)) { - LOG(ERROR) << "Failed to parse LimitInfo"; - sensors_parsed->clear(); - return false; - } - support_hard_limit = true; - } - - // Parse linked power info - std::string power_rail; - bool high_power_check = false; - bool throttling_with_power_link = false; - CdevArray cdev_floor_with_power_link; - cdev_floor_with_power_link.fill(0); - - const bool power_link_disabled = - android::base::GetBoolProperty(kPowerLinkDisabledProperty.data(), false); - if (!power_link_disabled) { - power_rail = values[j]["BindedPowerRail"].asString(); - - if (values[j]["HighPowerCheck"].asBool()) { - high_power_check = true; - } - LOG(INFO) << "Highpowercheck: " << std::boolalpha << high_power_check; - - if (values[j]["ThrottlingWithPowerLink"].asBool()) { - throttling_with_power_link = true; - } - LOG(INFO) << "ThrottlingwithPowerLink: " << std::boolalpha - << throttling_with_power_link; - - sub_values = values[j]["CdevFloorWithPowerLink"]; - if (sub_values.size()) { - LOG(INFO) << "Sensor[" << name << "]: Start to parse " << cdev_name - << "'s CdevFloorWithPowerLink"; - if (!getIntFromJsonValues(sub_values, &cdev_floor_with_power_link, false, - false)) { - LOG(ERROR) << "Failed to parse CdevFloor"; - sensors_parsed->clear(); - return false; - } - } - sub_values = values[j]["PowerThreshold"]; - if (sub_values.size()) { - LOG(INFO) << "Sensor[" << name << "]: Start to parse " << cdev_name - << "'s PowerThreshold"; - if (!getFloatFromJsonValues(sub_values, &power_thresholds, false, false)) { - LOG(ERROR) << "Failed to parse power thresholds"; - sensors_parsed->clear(); - return false; - } - if (values[j]["ReleaseLogic"].asString() == "INCREASE") { - release_logic = ReleaseLogic::INCREASE; - LOG(INFO) << "Release logic: INCREASE"; - } else if (values[j]["ReleaseLogic"].asString() == "DECREASE") { - release_logic = ReleaseLogic::DECREASE; - LOG(INFO) << "Release logic: DECREASE"; - } else if (values[j]["ReleaseLogic"].asString() == "STEPWISE") { - release_logic = ReleaseLogic::STEPWISE; - LOG(INFO) << "Release logic: STEPWISE"; - } else if (values[j]["ReleaseLogic"].asString() == "RELEASE_TO_FLOOR") { - release_logic = ReleaseLogic::RELEASE_TO_FLOOR; - LOG(INFO) << "Release logic: RELEASE_TO_FLOOR"; - } else { - LOG(ERROR) << "Release logic is invalid"; - sensors_parsed->clear(); - return false; - } - } - } - - binded_cdev_info_map[cdev_name] = { - .limit_info = limit_info, - .power_thresholds = power_thresholds, - .release_logic = release_logic, - .high_power_check = high_power_check, - .throttling_with_power_link = throttling_with_power_link, - .cdev_weight_for_pid = cdev_weight_for_pid, - .cdev_ceiling = cdev_ceiling, - .max_release_step = max_release_step, - .max_throttle_step = max_throttle_step, - .cdev_floor_with_power_link = cdev_floor_with_power_link, - .power_rail = power_rail, - }; - } - - std::unordered_map<std::string, ThrottlingArray> excluded_power_info_map; - values = sensors[i]["ExcludedPowerInfo"]; - for (Json::Value::ArrayIndex j = 0; j < values.size(); ++j) { - Json::Value sub_values; - const std::string &power_rail = values[j]["PowerRail"].asString(); - if (power_rail.empty()) { - LOG(ERROR) << "Sensor[" << name << "] failed to parse excluded PowerRail"; - sensors_parsed->clear(); - return false; - } - ThrottlingArray power_weight; - power_weight.fill(1); - if (!values[j]["PowerWeight"].empty()) { - LOG(INFO) << "Sensor[" << name << "]: Start to parse " << power_rail - << "'s PowerWeight"; - if (!getFloatFromJsonValues(values[j]["PowerWeight"], &power_weight, false, - false)) { - LOG(ERROR) << "Failed to parse PowerWeight"; - sensors_parsed->clear(); - return false; - } - } - excluded_power_info_map[power_rail] = power_weight; - } - if (is_hidden && send_cb) { LOG(ERROR) << "is_hidden and send_cb cannot be enabled together"; sensors_parsed->clear(); return false; } - bool is_watch = (send_cb | send_powerhint | support_pid | support_hard_limit); - LOG(INFO) << "Sensor[" << name << "]'s is_watch: " << std::boolalpha << is_watch; - std::unique_ptr<VirtualSensorInfo> virtual_sensor_info; - if (is_virtual_sensor) { - virtual_sensor_info.reset(new VirtualSensorInfo{linked_sensors, coefficients, offset, - trigger_sensor, formula}); + if (!ParseVirtualSensorInfo(name, sensors[i], &virtual_sensor_info)) { + LOG(ERROR) << "Sensor[" << name << "]: failed to parse virtual sensor info"; + sensors_parsed->clear(); + return false; + } + + bool support_throttling = false; // support pid or hard limit + std::shared_ptr<ThrottlingInfo> throttling_info; + if (!ParseSensorThrottlingInfo(name, sensors[i], &support_throttling, &throttling_info)) { + LOG(ERROR) << "Sensor[" << name << "]: failed to parse throttling info"; + sensors_parsed->clear(); + return false; } - std::shared_ptr<ThrottlingInfo> throttling_info(new ThrottlingInfo{ - k_po, k_pu, k_i, k_d, i_max, max_alloc_power, min_alloc_power, s_power, i_cutoff, - i_default, tran_cycle, excluded_power_info_map, binded_cdev_info_map}); + bool is_watch = (send_cb | send_powerhint | support_throttling); + LOG(INFO) << "Sensor[" << name << "]'s is_watch: " << std::boolalpha << is_watch; (*sensors_parsed)[name] = { .type = sensor_type, @@ -819,24 +847,9 @@ bool ParseSensorInfo(std::string_view config_path, return true; } -bool ParseCoolingDevice(std::string_view config_path, +bool ParseCoolingDevice(const Json::Value &config, std::unordered_map<std::string, CdevInfo> *cooling_devices_parsed) { - std::string json_doc; - if (!android::base::ReadFileToString(config_path.data(), &json_doc)) { - LOG(ERROR) << "Failed to read JSON config from " << config_path; - return false; - } - Json::Value root; - Json::CharReaderBuilder builder; - std::unique_ptr<Json::CharReader> reader(builder.newCharReader()); - std::string errorMessage; - - if (!reader->parse(&*json_doc.begin(), &*json_doc.end(), &root, &errorMessage)) { - LOG(ERROR) << "Failed to parse JSON config: " << errorMessage; - return false; - } - - Json::Value cooling_devices = root["CoolingDevices"]; + Json::Value cooling_devices = config["CoolingDevices"]; std::size_t total_parsed = 0; std::unordered_set<std::string> cooling_devices_name_parsed; @@ -844,8 +857,7 @@ bool ParseCoolingDevice(std::string_view config_path, const std::string &name = cooling_devices[i]["Name"].asString(); LOG(INFO) << "CoolingDevice[" << i << "]'s Name: " << name; if (name.empty()) { - LOG(ERROR) << "Failed to read " - << "CoolingDevice[" << i << "]'s Name"; + LOG(ERROR) << "Failed to read CoolingDevice[" << i << "]'s Name"; cooling_devices_parsed->clear(); return false; } @@ -862,8 +874,8 @@ bool ParseCoolingDevice(std::string_view config_path, CoolingType cooling_device_type; if (!getTypeFromString(cooling_device_type_str, &cooling_device_type)) { - LOG(ERROR) << "Invalid " - << "CoolingDevice[" << name << "]'s Type: " << cooling_device_type_str; + LOG(ERROR) << "Invalid CoolingDevice[" << name + << "]'s Type: " << cooling_device_type_str; cooling_devices_parsed->clear(); return false; } @@ -903,24 +915,9 @@ bool ParseCoolingDevice(std::string_view config_path, return true; } -bool ParsePowerRailInfo(std::string_view config_path, +bool ParsePowerRailInfo(const Json::Value &config, std::unordered_map<std::string, PowerRailInfo> *power_rails_parsed) { - std::string json_doc; - if (!android::base::ReadFileToString(config_path.data(), &json_doc)) { - LOG(ERROR) << "Failed to read JSON config from " << config_path; - return false; - } - Json::Value root; - Json::CharReaderBuilder builder; - std::unique_ptr<Json::CharReader> reader(builder.newCharReader()); - std::string errorMessage; - - if (!reader->parse(&*json_doc.begin(), &*json_doc.end(), &root, &errorMessage)) { - LOG(ERROR) << "Failed to parse JSON config: " << errorMessage; - return false; - } - - Json::Value power_rails = root["PowerRails"]; + Json::Value power_rails = config["PowerRails"]; std::size_t total_parsed = 0; std::unordered_set<std::string> power_rails_name_parsed; @@ -928,8 +925,7 @@ bool ParsePowerRailInfo(std::string_view config_path, const std::string &name = power_rails[i]["Name"].asString(); LOG(INFO) << "PowerRail[" << i << "]'s Name: " << name; if (name.empty()) { - LOG(ERROR) << "Failed to read " - << "PowerRail[" << i << "]'s Name"; + LOG(ERROR) << "Failed to read PowerRail[" << i << "]'s Name"; power_rails_parsed->clear(); return false; } @@ -1046,8 +1042,143 @@ bool ParsePowerRailInfo(std::string_view config_path, return true; } +template <typename T, typename U> +bool ParseStatsInfo(const Json::Value &stats_config, + const std::unordered_map<std::string, U> &entity_info, StatsInfo<T> *stats_info, + T min_value) { + if (stats_config.empty()) { + LOG(INFO) << "No stats config"; + return true; + } + std::variant<bool, std::unordered_set<std::string>> + record_by_default_threshold_all_or_name_set_ = false; + if (stats_config["DefaultThresholdEnableAll"].empty() || + !stats_config["DefaultThresholdEnableAll"].isBool()) { + LOG(INFO) << "Failed to read stats DefaultThresholdEnableAll, set to 'false'"; + } else if (stats_config["DefaultThresholdEnableAll"].asBool()) { + record_by_default_threshold_all_or_name_set_ = true; + } + LOG(INFO) << "DefaultThresholdEnableAll " << std::boolalpha + << std::get<bool>(record_by_default_threshold_all_or_name_set_) << std::noboolalpha; + + Json::Value values = stats_config["RecordWithDefaultThreshold"]; + if (values.size()) { + if (std::get<bool>(record_by_default_threshold_all_or_name_set_)) { + LOG(ERROR) << "Cannot enable record with default threshold when " + "DefaultThresholdEnableAll true."; + return false; + } + record_by_default_threshold_all_or_name_set_ = std::unordered_set<std::string>(); + for (Json::Value::ArrayIndex i = 0; i < values.size(); ++i) { + std::string name = values[i].asString(); + if (!entity_info.count(name)) { + LOG(ERROR) << "Unknown name [" << name << "] not present in entity_info."; + return false; + } + std::get<std::unordered_set<std::string>>(record_by_default_threshold_all_or_name_set_) + .insert(name); + } + } else { + LOG(INFO) << "No stat by default threshold enabled."; + } + + std::unordered_map<std::string, std::vector<ThresholdList<T>>> record_by_threshold; + values = stats_config["RecordWithThreshold"]; + if (values.size()) { + Json::Value threshold_values; + for (Json::Value::ArrayIndex i = 0; i < values.size(); i++) { + const std::string &name = values[i]["Name"].asString(); + if (!entity_info.count(name)) { + LOG(ERROR) << "Unknown name [" << name << "] not present in entity_info."; + return false; + } + + std::optional<std::string> logging_name; + if (!values[i]["LoggingName"].empty()) { + logging_name = values[i]["LoggingName"].asString(); + LOG(INFO) << "For [" << name << "]" + << ", stats logging name is [" << logging_name.value() << "]"; + } + + LOG(INFO) << "Start to parse stats threshold for [" << name << "]"; + threshold_values = values[i]["Thresholds"]; + if (threshold_values.empty()) { + LOG(ERROR) << "Empty stats threshold not valid."; + return false; + } + const auto &threshold_values_count = threshold_values.size(); + if (threshold_values_count > kMaxStatsThresholdCount) { + LOG(ERROR) << "Number of stats threshold " << threshold_values_count + << " greater than max " << kMaxStatsThresholdCount; + return false; + } + std::vector<T> stats_threshold(threshold_values_count); + T prev_value = min_value; + LOG(INFO) << "Thresholds:"; + for (Json::Value::ArrayIndex i = 0; i < threshold_values_count; ++i) { + stats_threshold[i] = std::is_floating_point_v<T> + ? getFloatFromValue(threshold_values[i]) + : getIntFromValue(threshold_values[i]); + if (stats_threshold[i] <= prev_value) { + LOG(ERROR) << "Invalid array[" << i << "]" << stats_threshold[i] + << " is <=" << prev_value; + return false; + } + prev_value = stats_threshold[i]; + LOG(INFO) << "[" << i << "]: " << stats_threshold[i]; + } + record_by_threshold[name].emplace_back(logging_name, stats_threshold); + } + } else { + LOG(INFO) << "No stat by threshold enabled."; + } + + (*stats_info) = {.record_by_default_threshold_all_or_name_set_ = + record_by_default_threshold_all_or_name_set_, + .record_by_threshold = record_by_threshold}; + return true; +} + +bool ParseStatsConfig(const Json::Value &config, + const std::unordered_map<std::string, SensorInfo> &sensor_info_map_, + const std::unordered_map<std::string, CdevInfo> &cooling_device_info_map_, + StatsConfig *stats_config_parsed) { + Json::Value stats_config = config["Stats"]; + + if (stats_config.empty()) { + LOG(INFO) << "No Stats Config present."; + return true; + } + + LOG(INFO) << "Parse Stats Config for Sensor Temp."; + // Parse sensor stats config + if (!ParseStatsInfo(stats_config["Sensors"], sensor_info_map_, + &stats_config_parsed->sensor_stats_info, + std::numeric_limits<float>::lowest())) { + LOG(ERROR) << "Failed to parse sensor temp stats info."; + stats_config_parsed->clear(); + return false; + } + + // Parse cooling device user vote + if (stats_config["CoolingDevices"].empty()) { + LOG(INFO) << "No cooling device stats present."; + return true; + } + + LOG(INFO) << "Parse Stats Config for Sensor CDev Request."; + if (!ParseStatsInfo(stats_config["CoolingDevices"]["RecordVotePerSensor"], + cooling_device_info_map_, &stats_config_parsed->cooling_device_request_info, + -1)) { + LOG(ERROR) << "Failed to parse cooling device user vote stats info."; + stats_config_parsed->clear(); + return false; + } + return true; +} + } // namespace implementation -} // namespace V2_0 } // namespace thermal } // namespace hardware } // namespace android +} // namespace aidl diff --git a/thermal/utils/thermal_info.h b/thermal/utils/thermal_info.h index e56b358d..5b2e8b80 100644 --- a/thermal/utils/thermal_info.h +++ b/thermal/utils/thermal_info.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2018 The Android Open Source Project + * Copyright (C) 2022 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. @@ -16,27 +16,34 @@ #pragma once -#include <android/hardware/thermal/2.0/IThermal.h> +#include <aidl/android/hardware/thermal/CoolingType.h> +#include <aidl/android/hardware/thermal/TemperatureType.h> +#include <aidl/android/hardware/thermal/ThrottlingSeverity.h> +#include <json/value.h> +#include <chrono> #include <string> #include <unordered_map> +#include <unordered_set> +#include <variant> +namespace aidl { namespace android { namespace hardware { namespace thermal { -namespace V2_0 { namespace implementation { -using ::android::hardware::hidl_enum_range; -using CoolingType_2_0 = ::android::hardware::thermal::V2_0::CoolingType; -using TemperatureType_2_0 = ::android::hardware::thermal::V2_0::TemperatureType; -using ::android::hardware::thermal::V2_0::ThrottlingSeverity; -constexpr size_t kThrottlingSeverityCount = std::distance( - hidl_enum_range<ThrottlingSeverity>().begin(), hidl_enum_range<ThrottlingSeverity>().end()); +constexpr size_t kThrottlingSeverityCount = + std::distance(::ndk::enum_range<ThrottlingSeverity>().begin(), + ::ndk::enum_range<ThrottlingSeverity>().end()); using ThrottlingArray = std::array<float, static_cast<size_t>(kThrottlingSeverityCount)>; using CdevArray = std::array<int, static_cast<size_t>(kThrottlingSeverityCount)>; constexpr std::chrono::milliseconds kMinPollIntervalMs = std::chrono::milliseconds(2000); constexpr std::chrono::milliseconds kUeventPollTimeoutMs = std::chrono::milliseconds(300000); +// Max number of time_in_state buckets is 20 in atoms +// VendorSensorCoolingDeviceStats, VendorTempResidencyStats +constexpr int kMaxStatsResidencyCount = 20; +constexpr int kMaxStatsThresholdCount = kMaxStatsResidencyCount - 1; enum FormulaOption : uint32_t { COUNT_THRESHOLD = 0, @@ -45,11 +52,55 @@ enum FormulaOption : uint32_t { MINIMUM, }; +template <typename T> +struct ThresholdList { + std::optional<std::string> logging_name; + std::vector<T> thresholds; + explicit ThresholdList(std::optional<std::string> logging_name, std::vector<T> thresholds) + : logging_name(logging_name), thresholds(thresholds) {} + + ThresholdList() = default; + ThresholdList(const ThresholdList &) = default; + ThresholdList &operator=(const ThresholdList &) = default; + ThresholdList(ThresholdList &&) = default; + ThresholdList &operator=(ThresholdList &&) = default; + ~ThresholdList() = default; +}; + +template <typename T> +struct StatsInfo { + // if bool, record all or none depending on flag + // if set, check name present in set + std::variant<bool, std::unordered_set<std::string> > + record_by_default_threshold_all_or_name_set_; + // map name to list of thresholds + std::unordered_map<std::string, std::vector<ThresholdList<T> > > record_by_threshold; + void clear() { + record_by_default_threshold_all_or_name_set_ = false; + record_by_threshold.clear(); + } +}; + +struct StatsConfig { + StatsInfo<float> sensor_stats_info; + StatsInfo<int> cooling_device_request_info; + void clear() { + sensor_stats_info.clear(); + cooling_device_request_info.clear(); + } +}; + +enum SensorFusionType : uint32_t { + SENSOR = 0, + ODPM, +}; + struct VirtualSensorInfo { std::vector<std::string> linked_sensors; + std::vector<SensorFusionType> linked_sensors_type; std::vector<float> coefficients; float offset; - std::string trigger_sensor; + std::vector<std::string> trigger_sensors; FormulaOption formula; }; @@ -102,7 +153,7 @@ struct ThrottlingInfo { }; struct SensorInfo { - TemperatureType_2_0 type; + TemperatureType type; ThrottlingArray hot_thresholds; ThrottlingArray cold_thresholds; ThrottlingArray hot_hysteresis; @@ -122,7 +173,7 @@ struct SensorInfo { }; struct CdevInfo { - CoolingType_2_0 type; + CoolingType type; std::string read_path; std::string write_path; std::vector<float> state2power; @@ -136,15 +187,19 @@ struct PowerRailInfo { std::unique_ptr<VirtualPowerRailInfo> virtual_power_rail_info; }; -bool ParseSensorInfo(std::string_view config_path, +bool ParseThermalConfig(std::string_view config_path, Json::Value *config); +bool ParseSensorInfo(const Json::Value &config, std::unordered_map<std::string, SensorInfo> *sensors_parsed); -bool ParseCoolingDevice(std::string_view config_path, +bool ParseCoolingDevice(const Json::Value &config, std::unordered_map<std::string, CdevInfo> *cooling_device_parsed); -bool ParsePowerRailInfo(std::string_view config_path, +bool ParsePowerRailInfo(const Json::Value &config, std::unordered_map<std::string, PowerRailInfo> *power_rail_parsed); - +bool ParseStatsConfig(const Json::Value &config, + const std::unordered_map<std::string, SensorInfo> &sensor_info_map_, + const std::unordered_map<std::string, CdevInfo> &cooling_device_info_map_, + StatsConfig *stats_config); } // namespace implementation -} // namespace V2_0 } // namespace thermal } // namespace hardware } // namespace android +} // namespace aidl diff --git a/thermal/utils/thermal_stats_helper.cpp b/thermal/utils/thermal_stats_helper.cpp new file mode 100644 index 00000000..daaaf1c6 --- /dev/null +++ b/thermal/utils/thermal_stats_helper.cpp @@ -0,0 +1,509 @@ +/* + * Copyright (C) 2022 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. + */ + +#include "thermal_stats_helper.h" + +#include <android-base/logging.h> +#include <android/binder_manager.h> +#include <hardware/google/pixel/pixelstats/pixelatoms.pb.h> + +#include <algorithm> +#include <numeric> +#include <string_view> + +namespace aidl { +namespace android { +namespace hardware { +namespace thermal { +namespace implementation { + +constexpr std::string_view kCustomThresholdSetSuffix("-TH-"); +constexpr std::string_view kCompressedThresholdSuffix("-CMBN-TH"); + +using aidl::android::frameworks::stats::VendorAtom; +namespace PixelAtoms = ::android::hardware::google::pixel::PixelAtoms; + +namespace { +static std::shared_ptr<IStats> stats_client = nullptr; +std::shared_ptr<IStats> getStatsService() { + static std::once_flag statsServiceFlag; + std::call_once(statsServiceFlag, []() { + const std::string instance = std::string() + IStats::descriptor + "/default"; + bool isStatsDeclared = AServiceManager_isDeclared(instance.c_str()); + if (!isStatsDeclared) { + LOG(ERROR) << "Stats service is not registered."; + return; + } + stats_client = IStats::fromBinder( + ndk::SpAIBinder(AServiceManager_waitForService(instance.c_str()))); + }); + return stats_client; +} + +bool isRecordByDefaultThreshold(const std::variant<bool, std::unordered_set<std::string>> + &record_by_default_threshold_all_or_name_set_, + std::string_view name) { + if (std::holds_alternative<bool>(record_by_default_threshold_all_or_name_set_)) { + return std::get<bool>(record_by_default_threshold_all_or_name_set_); + } + return std::get<std::unordered_set<std::string>>(record_by_default_threshold_all_or_name_set_) + .count(name.data()); +} + +template <typename T> +int calculateThresholdBucket(const std::vector<T> &thresholds, T value) { + if (thresholds.empty()) { + LOG(VERBOSE) << "No threshold present, so bucket is " << value << " as int."; + return static_cast<int>(value); + } + auto threshold_idx = std::upper_bound(thresholds.begin(), thresholds.end(), value); + int bucket = (threshold_idx - thresholds.begin()); + LOG(VERBOSE) << "For value: " << value << " bucket is: " << bucket; + return bucket; +} + +} // namespace + +bool ThermalStatsHelper::initializeStats( + const Json::Value &config, + const std::unordered_map<std::string, SensorInfo> &sensor_info_map_, + const std::unordered_map<std::string, CdevInfo> &cooling_device_info_map_) { + StatsConfig stats_config; + if (!ParseStatsConfig(config, sensor_info_map_, cooling_device_info_map_, &stats_config)) { + LOG(ERROR) << "Failed to parse stats config"; + return false; + } + bool is_initialized_ = + initializeSensorTempStats(stats_config.sensor_stats_info, sensor_info_map_) && + initializeSensorCdevRequestStats(stats_config.cooling_device_request_info, + sensor_info_map_, cooling_device_info_map_); + if (is_initialized_) { + last_total_stats_report_time = boot_clock::now(); + LOG(INFO) << "Thermal Stats Initialized Successfully"; + } + return is_initialized_; +} + +bool ThermalStatsHelper::initializeSensorCdevRequestStats( + const StatsInfo<int> &request_stats_info, + const std::unordered_map<std::string, SensorInfo> &sensor_info_map_, + const std::unordered_map<std::string, CdevInfo> &cooling_device_info_map_) { + std::unique_lock<std::shared_mutex> _lock(sensor_cdev_request_stats_map_mutex_); + for (const auto &[sensor, sensor_info] : sensor_info_map_) { + for (const auto &binded_cdev_info_pair : + sensor_info.throttling_info->binded_cdev_info_map) { + const auto &cdev = binded_cdev_info_pair.first; + const auto &max_state = + cooling_device_info_map_.at(binded_cdev_info_pair.first).max_state; + // Record by all state + if (isRecordByDefaultThreshold( + request_stats_info.record_by_default_threshold_all_or_name_set_, cdev)) { + // if the number of states is greater / equal(as state starts from 0) than + // residency_buckets in atom combine the initial states + if (max_state >= kMaxStatsResidencyCount) { + // buckets = [max_state -kMaxStatsResidencyCount + 1, ...max_state] + // idx = [1, .. max_state - (max_state - kMaxStatsResidencyCount + 1) + 1] + // idx = [1, .. kMaxStatsResidencyCount] + const auto starting_state = max_state - kMaxStatsResidencyCount + 1; + std::vector<int> thresholds(kMaxStatsResidencyCount); + std::iota(thresholds.begin(), thresholds.end(), starting_state); + const auto logging_name = cdev + kCompressedThresholdSuffix.data(); + ThresholdList<int> threshold_list(logging_name, thresholds); + sensor_cdev_request_stats_map_[sensor][cdev] + .stats_by_custom_threshold.emplace_back(threshold_list); + } else { + // buckets = [0, 1, 2, 3, ...max_state] + const auto default_threshold_time_in_state_size = max_state + 1; + sensor_cdev_request_stats_map_[sensor][cdev].stats_by_default_threshold = + StatsRecord(default_threshold_time_in_state_size); + } + LOG(INFO) << "Sensor Cdev user vote stats on basis of all state initialized for [" + << sensor << "-" << cdev << "]"; + } + + // Record by custom threshold + if (request_stats_info.record_by_threshold.count(cdev)) { + for (const auto &threshold_list : request_stats_info.record_by_threshold.at(cdev)) { + // check last threshold value(which is >= number of buckets as numbers in + // threshold are strictly increasing from 0) is less than max_state + if (threshold_list.thresholds.back() >= max_state) { + LOG(ERROR) << "For sensor " << sensor << " bindedCdev: " << cdev + << "Invalid bindedCdev stats threshold: " + << threshold_list.thresholds.back() << " >= " << max_state; + sensor_cdev_request_stats_map_.clear(); + return false; + } + sensor_cdev_request_stats_map_[sensor][cdev] + .stats_by_custom_threshold.emplace_back(threshold_list); + LOG(INFO) + << "Sensor Cdev user vote stats on basis of threshold initialized for [" + << sensor << "-" << cdev << "]"; + } + } + } + } + return true; +} + +bool ThermalStatsHelper::initializeSensorTempStats( + const StatsInfo<float> &sensor_stats_info, + const std::unordered_map<std::string, SensorInfo> &sensor_info_map_) { + std::unique_lock<std::shared_mutex> _lock(sensor_temp_stats_map_mutex_); + const int severity_time_in_state_size = kThrottlingSeverityCount; + for (const auto &[sensor, sensor_info] : sensor_info_map_) { + // Record by severity + if (sensor_info.is_watch && + isRecordByDefaultThreshold( + sensor_stats_info.record_by_default_threshold_all_or_name_set_, sensor)) { + // number of buckets = number of severity + sensor_temp_stats_map_[sensor].stats_by_default_threshold = + StatsRecord(severity_time_in_state_size); + LOG(INFO) << "Sensor temp stats on basis of severity initialized for [" << sensor + << "]"; + } + + // Record by custom threshold + if (sensor_stats_info.record_by_threshold.count(sensor)) { + for (const auto &threshold_list : sensor_stats_info.record_by_threshold.at(sensor)) { + sensor_temp_stats_map_[sensor].stats_by_custom_threshold.emplace_back( + threshold_list); + LOG(INFO) << "Sensor temp stats on basis of threshold initialized for [" << sensor + << "]"; + } + } + } + return true; +} + +void ThermalStatsHelper::updateStatsRecord(StatsRecord *stats_record, int new_state) { + const auto now = boot_clock::now(); + const auto cur_state_duration = std::chrono::duration_cast<std::chrono::milliseconds>( + now - stats_record->cur_state_start_time); + LOG(VERBOSE) << "Adding duration " << cur_state_duration.count() + << " for cur_state: " << stats_record->cur_state << " with value: " + << stats_record->time_in_state_ms[stats_record->cur_state].count(); + // Update last record end time + stats_record->time_in_state_ms[stats_record->cur_state] += cur_state_duration; + stats_record->cur_state_start_time = now; + stats_record->cur_state = new_state; +} + +void ThermalStatsHelper::updateSensorCdevRequestStats(std::string_view sensor, + std::string_view cdev, int new_value) { + std::unique_lock<std::shared_mutex> _lock(sensor_cdev_request_stats_map_mutex_); + if (!sensor_cdev_request_stats_map_.count(sensor.data()) || + !sensor_cdev_request_stats_map_[sensor.data()].count(cdev.data())) { + return; + } + auto &request_stats = sensor_cdev_request_stats_map_[sensor.data()][cdev.data()]; + for (auto &stats_by_threshold : request_stats.stats_by_custom_threshold) { + int value = calculateThresholdBucket(stats_by_threshold.thresholds, new_value); + if (value != stats_by_threshold.stats_record.cur_state) { + LOG(VERBOSE) << "Updating bindedCdev stats for sensor: " << sensor.data() + << " , cooling_device: " << cdev.data() << " with new value: " << value; + updateStatsRecord(&stats_by_threshold.stats_record, value); + } + } + + if (request_stats.stats_by_default_threshold.has_value()) { + auto &stats_record = request_stats.stats_by_default_threshold.value(); + if (new_value != stats_record.cur_state) { + LOG(VERBOSE) << "Updating bindedCdev stats for sensor: " << sensor.data() + << " , cooling_device: " << cdev.data() + << " with new value: " << new_value; + updateStatsRecord(&stats_record, new_value); + } + } +} + +void ThermalStatsHelper::updateSensorTempStatsByThreshold(std::string_view sensor, + float temperature) { + std::unique_lock<std::shared_mutex> _lock(sensor_temp_stats_map_mutex_); + if (!sensor_temp_stats_map_.count(sensor.data())) { + return; + } + auto &sensor_temp_stats = sensor_temp_stats_map_[sensor.data()]; + for (auto &stats_by_threshold : sensor_temp_stats.stats_by_custom_threshold) { + int value = calculateThresholdBucket(stats_by_threshold.thresholds, temperature); + if (value != stats_by_threshold.stats_record.cur_state) { + LOG(VERBOSE) << "Updating sensor stats for sensor: " << sensor.data() + << " with value: " << value; + updateStatsRecord(&stats_by_threshold.stats_record, value); + } + } + if (temperature > sensor_temp_stats.max_temp) { + sensor_temp_stats.max_temp = temperature; + sensor_temp_stats.max_temp_timestamp = system_clock::now(); + } + if (temperature < sensor_temp_stats.min_temp) { + sensor_temp_stats.min_temp = temperature; + sensor_temp_stats.min_temp_timestamp = system_clock::now(); + } +} + +void ThermalStatsHelper::updateSensorTempStatsBySeverity(std::string_view sensor, + const ThrottlingSeverity &severity) { + std::unique_lock<std::shared_mutex> _lock(sensor_temp_stats_map_mutex_); + if (sensor_temp_stats_map_.count(sensor.data()) && + sensor_temp_stats_map_[sensor.data()].stats_by_default_threshold.has_value()) { + auto &stats_record = + sensor_temp_stats_map_[sensor.data()].stats_by_default_threshold.value(); + int value = static_cast<int>(severity); + if (value != stats_record.cur_state) { + LOG(VERBOSE) << "Updating sensor stats for sensor: " << sensor.data() + << " with value: " << value; + updateStatsRecord(&stats_record, value); + } + } +} + +int ThermalStatsHelper::reportStats() { + const auto curTime = boot_clock::now(); + const auto since_last_total_stats_update_ms = + std::chrono::duration_cast<std::chrono::milliseconds>(curTime - + last_total_stats_report_time); + LOG(VERBOSE) << "Duration from last total stats update is: " + << since_last_total_stats_update_ms.count(); + if (since_last_total_stats_update_ms < kUpdateIntervalMs) { + LOG(VERBOSE) << "Time elapsed since last update less than " << kUpdateIntervalMs.count(); + return 0; + } + + const std::shared_ptr<IStats> stats_client = getStatsService(); + if (!stats_client) { + LOG(ERROR) << "Unable to get AIDL Stats service"; + return -1; + } + int count_failed_reporting = + reportAllSensorTempStats(stats_client) + reportAllSensorCdevRequestStats(stats_client); + last_total_stats_report_time = curTime; + return count_failed_reporting; +} + +int ThermalStatsHelper::reportAllSensorTempStats(const std::shared_ptr<IStats> &stats_client) { + int count_failed_reporting = 0; + std::unique_lock<std::shared_mutex> _lock(sensor_temp_stats_map_mutex_); + for (auto &[sensor, temp_stats] : sensor_temp_stats_map_) { + for (size_t threshold_set_idx = 0; + threshold_set_idx < temp_stats.stats_by_custom_threshold.size(); threshold_set_idx++) { + auto &stats_by_threshold = temp_stats.stats_by_custom_threshold[threshold_set_idx]; + std::string sensor_name = stats_by_threshold.logging_name.value_or( + sensor + kCustomThresholdSetSuffix.data() + std::to_string(threshold_set_idx)); + if (!reportSensorTempStats(stats_client, sensor_name, temp_stats, + &stats_by_threshold.stats_record)) { + count_failed_reporting++; + } + } + if (temp_stats.stats_by_default_threshold.has_value()) { + if (!reportSensorTempStats(stats_client, sensor, temp_stats, + &temp_stats.stats_by_default_threshold.value())) { + count_failed_reporting++; + } + } + } + return count_failed_reporting; +} + +bool ThermalStatsHelper::reportSensorTempStats(const std::shared_ptr<IStats> &stats_client, + std::string_view sensor, + const SensorTempStats &sensor_temp_stats, + StatsRecord *stats_record) { + LOG(VERBOSE) << "Reporting sensor stats for " << sensor; + // maintain a copy in case reporting fails + StatsRecord thermal_stats_before_reporting = *stats_record; + std::vector<VendorAtomValue> values(2); + values[0].set<VendorAtomValue::stringValue>(sensor); + std::vector<int64_t> time_in_state_ms = processStatsRecordForReporting(stats_record); + const auto since_last_update_ms = std::chrono::duration_cast<std::chrono::milliseconds>( + stats_record->cur_state_start_time - stats_record->last_stats_report_time); + values[1].set<VendorAtomValue::longValue>(since_last_update_ms.count()); + VendorAtomValue tmp; + for (auto &time_in_state : time_in_state_ms) { + tmp.set<VendorAtomValue::longValue>(time_in_state); + values.push_back(tmp); + } + auto remaining_residency_buckets_count = kMaxStatsResidencyCount - time_in_state_ms.size(); + if (remaining_residency_buckets_count > 0) { + tmp.set<VendorAtomValue::longValue>(0); + values.insert(values.end(), remaining_residency_buckets_count, tmp); + } + tmp.set<VendorAtomValue::floatValue>(sensor_temp_stats.max_temp); + values.push_back(tmp); + tmp.set<VendorAtomValue::longValue>( + system_clock::to_time_t(sensor_temp_stats.max_temp_timestamp)); + values.push_back(tmp); + tmp.set<VendorAtomValue::floatValue>(sensor_temp_stats.min_temp); + values.push_back(tmp); + tmp.set<VendorAtomValue::longValue>( + system_clock::to_time_t(sensor_temp_stats.min_temp_timestamp)); + values.push_back(tmp); + + if (!reportAtom(stats_client, PixelAtoms::Atom::kVendorTempResidencyStats, std::move(values))) { + LOG(ERROR) << "Unable to report VendorTempResidencyStats to Stats service for " + "sensor: " + << sensor; + *stats_record = restoreStatsRecordOnFailure(std::move(thermal_stats_before_reporting)); + return false; + } + // Update last time of stats reporting + stats_record->last_stats_report_time = boot_clock::now(); + return true; +} + +int ThermalStatsHelper::reportAllSensorCdevRequestStats( + const std::shared_ptr<IStats> &stats_client) { + int count_failed_reporting = 0; + std::unique_lock<std::shared_mutex> _lock(sensor_cdev_request_stats_map_mutex_); + for (auto &[sensor, cdev_request_stats_map] : sensor_cdev_request_stats_map_) { + for (auto &[cdev, request_stats] : cdev_request_stats_map) { + for (size_t threshold_set_idx = 0; + threshold_set_idx < request_stats.stats_by_custom_threshold.size(); + threshold_set_idx++) { + auto &stats_by_threshold = + request_stats.stats_by_custom_threshold[threshold_set_idx]; + std::string cdev_name = stats_by_threshold.logging_name.value_or( + cdev + kCustomThresholdSetSuffix.data() + + std::to_string(threshold_set_idx)); + if (!reportSensorCdevRequestStats(stats_client, sensor, cdev_name, + &stats_by_threshold.stats_record)) { + count_failed_reporting++; + } + } + + if (request_stats.stats_by_default_threshold.has_value()) { + if (!reportSensorCdevRequestStats( + stats_client, sensor, cdev, + &request_stats.stats_by_default_threshold.value())) { + count_failed_reporting++; + } + } + } + } + return count_failed_reporting; +} + +bool ThermalStatsHelper::reportSensorCdevRequestStats(const std::shared_ptr<IStats> &stats_client, + std::string_view sensor, + std::string_view cdev, + StatsRecord *stats_record) { + LOG(VERBOSE) << "Reporting bindedCdev stats for sensor: " << sensor + << " cooling_device: " << cdev; + // maintain a copy in case reporting fails + StatsRecord thermal_stats_before_reporting = *stats_record; + std::vector<VendorAtomValue> values(3); + values[0].set<VendorAtomValue::stringValue>(sensor); + values[1].set<VendorAtomValue::stringValue>(cdev); + std::vector<int64_t> time_in_state_ms = processStatsRecordForReporting(stats_record); + const auto since_last_update_ms = std::chrono::duration_cast<std::chrono::milliseconds>( + stats_record->cur_state_start_time - stats_record->last_stats_report_time); + values[2].set<VendorAtomValue::longValue>(since_last_update_ms.count()); + VendorAtomValue tmp; + for (auto &time_in_state : time_in_state_ms) { + tmp.set<VendorAtomValue::longValue>(time_in_state); + values.push_back(tmp); + } + + if (!reportAtom(stats_client, PixelAtoms::Atom::kVendorSensorCoolingDeviceStats, + std::move(values))) { + LOG(ERROR) << "Unable to report VendorSensorCoolingDeviceStats to Stats " + "service for sensor: " + << sensor << " cooling_device: " << cdev; + *stats_record = restoreStatsRecordOnFailure(std::move(thermal_stats_before_reporting)); + return false; + } + // Update last time of stats reporting + stats_record->last_stats_report_time = boot_clock::now(); + return true; +} + +std::vector<int64_t> ThermalStatsHelper::processStatsRecordForReporting(StatsRecord *stats_record) { + // update the last unclosed entry and start new record with same state + updateStatsRecord(stats_record, stats_record->cur_state); + std::vector<std::chrono::milliseconds> &time_in_state_ms = stats_record->time_in_state_ms; + // convert std::chrono::milliseconds time_in_state to int64_t vector for reporting + std::vector<int64_t> stats_residency(time_in_state_ms.size()); + std::transform(time_in_state_ms.begin(), time_in_state_ms.end(), stats_residency.begin(), + [](std::chrono::milliseconds time_ms) { return time_ms.count(); }); + // clear previous stats + std::fill(time_in_state_ms.begin(), time_in_state_ms.end(), std::chrono::milliseconds::zero()); + return stats_residency; +} + +bool ThermalStatsHelper::reportAtom(const std::shared_ptr<IStats> &stats_client, + const int32_t &atom_id, std::vector<VendorAtomValue> &&values) { + LOG(VERBOSE) << "Reporting thermal stats for atom_id " << atom_id; + // Send vendor atom to IStats HAL + VendorAtom event = {.reverseDomainName = "", .atomId = atom_id, .values = std::move(values)}; + const ndk::ScopedAStatus ret = stats_client->reportVendorAtom(event); + return ret.isOk(); +} + +StatsRecord ThermalStatsHelper::restoreStatsRecordOnFailure( + StatsRecord &&stats_record_before_failure) { + stats_record_before_failure.report_fail_count += 1; + // If consecutive count of failure is high, reset stat to avoid overflow + if (stats_record_before_failure.report_fail_count >= kMaxStatsReportingFailCount) { + return StatsRecord(stats_record_before_failure.time_in_state_ms.size(), + stats_record_before_failure.cur_state); + } else { + return stats_record_before_failure; + } +} + +std::unordered_map<std::string, SensorTempStats> ThermalStatsHelper::GetSensorTempStatsSnapshot() { + auto sensor_temp_stats_snapshot = sensor_temp_stats_map_; + for (auto &sensor_temp_stats_pair : sensor_temp_stats_snapshot) { + for (auto &temp_stats : sensor_temp_stats_pair.second.stats_by_custom_threshold) { + // update the last unclosed entry and start new record with same state + updateStatsRecord(&temp_stats.stats_record, temp_stats.stats_record.cur_state); + } + if (sensor_temp_stats_pair.second.stats_by_default_threshold.has_value()) { + auto &stats_by_default_threshold = + sensor_temp_stats_pair.second.stats_by_default_threshold.value(); + // update the last unclosed entry and start new record with same state + updateStatsRecord(&stats_by_default_threshold, stats_by_default_threshold.cur_state); + } + } + return sensor_temp_stats_snapshot; +} + +std::unordered_map<std::string, std::unordered_map<std::string, ThermalStats<int>>> +ThermalStatsHelper::GetSensorCoolingDeviceRequestStatsSnapshot() { + auto sensor_cdev_request_stats_snapshot = sensor_cdev_request_stats_map_; + for (auto &sensor_cdev_request_stats_pair : sensor_cdev_request_stats_snapshot) { + for (auto &cdev_request_stats_pair : sensor_cdev_request_stats_pair.second) { + for (auto &request_stats : cdev_request_stats_pair.second.stats_by_custom_threshold) { + // update the last unclosed entry and start new record with same state + updateStatsRecord(&request_stats.stats_record, + request_stats.stats_record.cur_state); + } + if (cdev_request_stats_pair.second.stats_by_default_threshold.has_value()) { + auto &stats_by_default_threshold = + cdev_request_stats_pair.second.stats_by_default_threshold.value(); + // update the last unclosed entry and start new record with same state + updateStatsRecord(&stats_by_default_threshold, + stats_by_default_threshold.cur_state); + } + } + } + return sensor_cdev_request_stats_snapshot; +} + +} // namespace implementation +} // namespace thermal +} // namespace hardware +} // namespace android +} // namespace aidl diff --git a/thermal/utils/thermal_stats_helper.h b/thermal/utils/thermal_stats_helper.h new file mode 100644 index 00000000..ef2f811f --- /dev/null +++ b/thermal/utils/thermal_stats_helper.h @@ -0,0 +1,170 @@ +/* + * Copyright (C) 2022 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. + */ + +#pragma once + +#include <aidl/android/frameworks/stats/IStats.h> +#include <aidl/android/hardware/thermal/Temperature.h> +#include <android-base/chrono_utils.h> + +#include <chrono> +#include <shared_mutex> +#include <string_view> +#include <unordered_map> +#include <vector> + +#include "thermal_info.h" + +namespace aidl { +namespace android { +namespace hardware { +namespace thermal { +namespace implementation { + +using aidl::android::frameworks::stats::IStats; +using aidl::android::frameworks::stats::VendorAtomValue; +using ::android::base::boot_clock; +using std::chrono::system_clock; +using SystemTimePoint = std::chrono::time_point<std::chrono::system_clock>; + +constexpr int kMaxStatsReportingFailCount = 3; + +struct StatsRecord { + int cur_state; /* temperature / cdev state at current time */ + boot_clock::time_point cur_state_start_time; + boot_clock::time_point last_stats_report_time = boot_clock::time_point::min(); + std::vector<std::chrono::milliseconds> time_in_state_ms; /* stats array */ + int report_fail_count = 0; /* Number of times failed to report stats */ + explicit StatsRecord(const size_t &time_in_state_size, int state = 0) + : cur_state(state), + cur_state_start_time(boot_clock::now()), + last_stats_report_time(boot_clock::now()), + report_fail_count(0) { + time_in_state_ms = std::vector<std::chrono::milliseconds>( + time_in_state_size, std::chrono::milliseconds::zero()); + } + StatsRecord() = default; + StatsRecord(const StatsRecord &) = default; + StatsRecord &operator=(const StatsRecord &) = default; + StatsRecord(StatsRecord &&) = default; + StatsRecord &operator=(StatsRecord &&) = default; + ~StatsRecord() = default; +}; + +template <typename ValueType> +struct StatsByThreshold { + std::vector<ValueType> thresholds; + std::optional<std::string> logging_name; + StatsRecord stats_record; + explicit StatsByThreshold(ThresholdList<ValueType> threshold_list) + : thresholds(threshold_list.thresholds), logging_name(threshold_list.logging_name) { + // number of states = number of thresholds + 1 + // e.g. threshold: [30, 50, 60] + // buckets: [MIN - 30, 30 - 50, 50-60, 60-MAX] + int time_in_state_size = threshold_list.thresholds.size() + 1; + stats_record = StatsRecord(time_in_state_size); + } + StatsByThreshold() = default; + StatsByThreshold(const StatsByThreshold &) = default; + StatsByThreshold &operator=(const StatsByThreshold &) = default; + StatsByThreshold(StatsByThreshold &&) = default; + StatsByThreshold &operator=(StatsByThreshold &&) = default; + ~StatsByThreshold() = default; +}; + +template <typename ValueType> +struct ThermalStats { + std::vector<StatsByThreshold<ValueType>> stats_by_custom_threshold; + std::optional<StatsRecord> stats_by_default_threshold; +}; + +struct SensorTempStats : ThermalStats<float> { + float max_temp = std::numeric_limits<float>::min(); + SystemTimePoint max_temp_timestamp = SystemTimePoint::min(); + float min_temp = std::numeric_limits<float>::max(); + SystemTimePoint min_temp_timestamp = SystemTimePoint::min(); +}; + +class ThermalStatsHelper { + public: + ThermalStatsHelper() = default; + ~ThermalStatsHelper() = default; + // Disallow copy and assign + ThermalStatsHelper(const ThermalStatsHelper &) = delete; + void operator=(const ThermalStatsHelper &) = delete; + + bool initializeStats(const Json::Value &config, + const std::unordered_map<std::string, SensorInfo> &sensor_info_map_, + const std::unordered_map<std::string, CdevInfo> &cooling_device_info_map_); + void updateSensorCdevRequestStats(std::string_view trigger_sensor, std::string_view cdev, + int new_state); + void updateSensorTempStatsBySeverity(std::string_view sensor, + const ThrottlingSeverity &severity); + void updateSensorTempStatsByThreshold(std::string_view sensor, float temperature); + /* + * Function to report all the stats by calling all specific stats reporting function. + * Returns: + * 0, if time_elapsed < kUpdateIntervalMs or if no failure in reporting + * -1, if failed to get AIDL stats services + * >0, count represents the number of stats failed to report. + */ + int reportStats(); + // Get a snapshot of Thermal Stats Sensor Map till that point in time + std::unordered_map<std::string, SensorTempStats> GetSensorTempStatsSnapshot(); + // Get a snapshot of Thermal Stats Sensor Map till that point in time + std::unordered_map<std::string, std::unordered_map<std::string, ThermalStats<int>>> + GetSensorCoolingDeviceRequestStatsSnapshot(); + + private: + static constexpr std::chrono::milliseconds kUpdateIntervalMs = + std::chrono::duration_cast<std::chrono::milliseconds>(24h); + boot_clock::time_point last_total_stats_report_time = boot_clock::time_point::min(); + + mutable std::shared_mutex sensor_temp_stats_map_mutex_; + // Temperature stats for each sensor being watched + std::unordered_map<std::string, SensorTempStats> sensor_temp_stats_map_; + mutable std::shared_mutex sensor_cdev_request_stats_map_mutex_; + // userVote request stat for the sensor to the corresponding cdev (sensor -> cdev -> + // StatsRecord) + std::unordered_map<std::string, std::unordered_map<std::string, ThermalStats<int>>> + sensor_cdev_request_stats_map_; + + bool initializeSensorTempStats( + const StatsInfo<float> &sensor_stats_info, + const std::unordered_map<std::string, SensorInfo> &sensor_info_map_); + bool initializeSensorCdevRequestStats( + const StatsInfo<int> &request_stats_info, + const std::unordered_map<std::string, SensorInfo> &sensor_info_map_, + const std::unordered_map<std::string, CdevInfo> &cooling_device_info_map_); + void updateStatsRecord(StatsRecord *stats_record, int new_state); + int reportAllSensorTempStats(const std::shared_ptr<IStats> &stats_client); + bool reportSensorTempStats(const std::shared_ptr<IStats> &stats_client, std::string_view sensor, + const SensorTempStats &sensor_temp_stats, StatsRecord *stats_record); + int reportAllSensorCdevRequestStats(const std::shared_ptr<IStats> &stats_client); + bool reportSensorCdevRequestStats(const std::shared_ptr<IStats> &stats_client, + std::string_view sensor, std::string_view cdev, + StatsRecord *stats_record); + bool reportAtom(const std::shared_ptr<IStats> &stats_client, const int32_t &atom_id, + std::vector<VendorAtomValue> &&values); + std::vector<int64_t> processStatsRecordForReporting(StatsRecord *stats_record); + StatsRecord restoreStatsRecordOnFailure(StatsRecord &&stats_record_before_failure); +}; + +} // namespace implementation +} // namespace thermal +} // namespace hardware +} // namespace android +} // namespace aidl diff --git a/thermal/utils/thermal_throttling.cpp b/thermal/utils/thermal_throttling.cpp index 6f2d1205..8aac95d4 100644 --- a/thermal/utils/thermal_throttling.cpp +++ b/thermal/utils/thermal_throttling.cpp @@ -13,6 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +#define ATRACE_TAG (ATRACE_TAG_THERMAL | ATRACE_TAG_HAL) #include "thermal_throttling.h" @@ -32,18 +33,18 @@ #include "power_files.h" #include "thermal_info.h" +namespace aidl { namespace android { namespace hardware { namespace thermal { -namespace V2_0 { namespace implementation { -using android::base::StringPrintf; +using ::android::base::StringPrintf; // To find the next PID target state according to the current thermal severity size_t getTargetStateOfPID(const SensorInfo &sensor_info, const ThrottlingSeverity curr_severity) { size_t target_state = 0; - for (const auto &severity : hidl_enum_range<ThrottlingSeverity>()) { + for (const auto &severity : ::ndk::enum_range<ThrottlingSeverity>()) { size_t state = static_cast<size_t>(severity); if (std::isnan(sensor_info.throttling_info->s_power[state])) { continue; @@ -131,6 +132,7 @@ bool ThermalThrottling::registerThermalThrottling( .pid_cdev_request_map[binded_cdev_pair.first] = 0; thermal_throttling_status_map_[sensor_name.data()] .cdev_status_map[binded_cdev_pair.first] = 0; + cdev_all_request_map_[binded_cdev_pair.first].insert(0); break; } } @@ -141,6 +143,7 @@ bool ThermalThrottling::registerThermalThrottling( .hardlimit_cdev_request_map[binded_cdev_pair.first] = 0; thermal_throttling_status_map_[sensor_name.data()] .cdev_status_map[binded_cdev_pair.first] = 0; + cdev_all_request_map_[binded_cdev_pair.first].insert(0); break; } } @@ -159,8 +162,7 @@ bool ThermalThrottling::registerThermalThrottling( } // return power budget based on PID algo -float ThermalThrottling::updatePowerBudget(const Temperature_2_0 &temp, - const SensorInfo &sensor_info, +float ThermalThrottling::updatePowerBudget(const Temperature &temp, const SensorInfo &sensor_info, std::chrono::milliseconds time_elapsed_ms, ThrottlingSeverity curr_severity) { float p = 0, d = 0; @@ -168,6 +170,7 @@ float ThermalThrottling::updatePowerBudget(const Temperature_2_0 &temp, bool target_changed = false; float budget_transient = 0.0; auto &throttling_status = thermal_throttling_status_map_.at(temp.name); + std::string sensor_name = temp.name; if (curr_severity == ThrottlingSeverity::NONE) { return power_budget; @@ -231,6 +234,24 @@ float ThermalThrottling::updatePowerBudget(const Temperature_2_0 &temp, << " i=" << throttling_status.i_budget << " d=" << d << " budget transient=" << budget_transient << " control target=" << target_state; + ATRACE_INT((sensor_name + std::string("-power_budget")).c_str(), + static_cast<int>(power_budget)); + ATRACE_INT((sensor_name + std::string("-s_power")).c_str(), + static_cast<int>(sensor_info.throttling_info->s_power[target_state])); + ATRACE_INT((sensor_name + std::string("-time_elapsed_ms")).c_str(), + static_cast<int>(time_elapsed_ms.count())); + ATRACE_INT((sensor_name + std::string("-budget_transient")).c_str(), + static_cast<int>(budget_transient)); + ATRACE_INT((sensor_name + std::string("-i")).c_str(), + static_cast<int>(throttling_status.i_budget)); + ATRACE_INT((sensor_name + std::string("-target_state")).c_str(), + static_cast<int>(target_state)); + + ATRACE_INT((sensor_name + std::string("-err")).c_str(), static_cast<int>(err / sensor_info.multiplier)); + ATRACE_INT((sensor_name + std::string("-p")).c_str(), static_cast<int>(p)); + ATRACE_INT((sensor_name + std::string("-d")).c_str(), static_cast<int>(d)); + ATRACE_INT((sensor_name + std::string("-temp")).c_str(), static_cast<int>(temp.value / sensor_info.multiplier)); + throttling_status.prev_power_budget = power_budget; return power_budget; @@ -238,8 +259,8 @@ float ThermalThrottling::updatePowerBudget(const Temperature_2_0 &temp, float ThermalThrottling::computeExcludedPower( const SensorInfo &sensor_info, const ThrottlingSeverity curr_severity, - const std::unordered_map<std::string, PowerStatus> &power_status_map, - std::string *log_buf) { + const std::unordered_map<std::string, PowerStatus> &power_status_map, std::string *log_buf, + std::string_view sensor_name) { float excluded_power = 0.0; for (const auto &excluded_power_info_pair : @@ -253,14 +274,22 @@ float ThermalThrottling::computeExcludedPower( "(%s: %0.2f mW, cdev_weight: %f)", excluded_power_info_pair.first.c_str(), last_updated_avg_power, excluded_power_info_pair.second[static_cast<size_t>(curr_severity)])); + + ATRACE_INT((std::string(sensor_name) + std::string("-") + + excluded_power_info_pair.first + std::string("-avg_power")) + .c_str(), + static_cast<int>(last_updated_avg_power)); } } + + ATRACE_INT((std::string(sensor_name) + std::string("-excluded_power")).c_str(), + static_cast<int>(excluded_power)); return excluded_power; } // Allocate power budget to binded cooling devices base on the real ODPM power data bool ThermalThrottling::allocatePowerToCdev( - const Temperature_2_0 &temp, const SensorInfo &sensor_info, + const Temperature &temp, const SensorInfo &sensor_info, const ThrottlingSeverity curr_severity, const std::chrono::milliseconds time_elapsed_ms, const std::unordered_map<std::string, PowerStatus> &power_status_map, const std::unordered_map<std::string, CdevInfo> &cooling_device_info_map) { @@ -278,9 +307,8 @@ bool ThermalThrottling::allocatePowerToCdev( auto total_power_budget = updatePowerBudget(temp, sensor_info, time_elapsed_ms, curr_severity); if (sensor_info.throttling_info->excluded_power_info_map.size()) { - std::string log_buf; - total_power_budget -= - computeExcludedPower(sensor_info, curr_severity, power_status_map, &log_buf); + total_power_budget -= computeExcludedPower(sensor_info, curr_severity, power_status_map, + &log_buf, temp.name); total_power_budget = std::max(total_power_budget, 0.0f); if (!log_buf.empty()) { LOG(INFO) << temp.name << " power budget=" << total_power_budget << " after " << log_buf @@ -326,6 +354,11 @@ bool ThermalThrottling::allocatePowerToCdev( power_data_invalid = true; break; } + + ATRACE_INT((temp.name + std::string("-") + + binded_cdev_info_pair.second.power_rail + std::string("-avg_power")) + .c_str(), + static_cast<int>(last_updated_avg_power)); } else { power_data_invalid = true; break; @@ -346,18 +379,21 @@ bool ThermalThrottling::allocatePowerToCdev( allocated_power += last_updated_avg_power; allocated_weight += cdev_weight; allocated_cdev.insert(binded_cdev_info_pair.first); - log_buf.append(StringPrintf("(%s: %0.2f mW)", - binded_cdev_info_pair.second.power_rail.c_str(), - last_updated_avg_power)); - + if (!binded_cdev_info_pair.second.power_rail.empty()) { + log_buf.append(StringPrintf("(%s: %0.2f mW)", + binded_cdev_info_pair.second.power_rail.c_str(), + last_updated_avg_power)); + } LOG(VERBOSE) << temp.name << " binded " << binded_cdev_info_pair.first << " has been already at min state 0"; } } else { const CdevInfo &cdev_info = cooling_device_info_map.at(binded_cdev_info_pair.first); - log_buf.append(StringPrintf("(%s: %0.2f mW)", - binded_cdev_info_pair.second.power_rail.c_str(), - last_updated_avg_power)); + if (!binded_cdev_info_pair.second.power_rail.empty()) { + log_buf.append(StringPrintf("(%s: %0.2f mW)", + binded_cdev_info_pair.second.power_rail.c_str(), + last_updated_avg_power)); + } // Ignore the power distribution if the CDEV has no space to reduce power if ((cdev_power_adjustment < 0 && thermal_throttling_status_map_[temp.name].pid_cdev_request_map.at( @@ -390,25 +426,37 @@ bool ThermalThrottling::allocatePowerToCdev( cdev_power_budget = 0; } - const auto curr_state = + int max_cdev_vote; + if (!getCdevMaxRequest(binded_cdev_info_pair.first, &max_cdev_vote)) { + return false; + } + + const auto curr_cdev_vote = thermal_throttling_status_map_[temp.name].pid_cdev_request_map.at( binded_cdev_info_pair.first); if (binded_cdev_info_pair.second.max_release_step != std::numeric_limits<int>::max() && - cdev_power_adjustment > 0) { - auto target_state = - std::max(curr_state - binded_cdev_info_pair.second.max_release_step, 0); - cdev_power_budget = - std::min(cdev_power_budget, cdev_info.state2power[target_state]); + (power_data_invalid || cdev_power_adjustment > 0)) { + if (!power_data_invalid && curr_cdev_vote < max_cdev_vote) { + cdev_power_budget = cdev_info.state2power[curr_cdev_vote]; + LOG(VERBOSE) << temp.name << "'s " << binded_cdev_info_pair.first + << " vote: " << curr_cdev_vote + << " is lower than max cdev vote: " << max_cdev_vote; + } else { + const auto target_state = std::max( + curr_cdev_vote - binded_cdev_info_pair.second.max_release_step, 0); + cdev_power_budget = + std::min(cdev_power_budget, cdev_info.state2power[target_state]); + } } if (binded_cdev_info_pair.second.max_throttle_step != std::numeric_limits<int>::max() && - cdev_power_adjustment < 0) { - auto target_state = - std::min(curr_state + binded_cdev_info_pair.second.max_throttle_step, - cdev_info.max_state); + (power_data_invalid || cdev_power_adjustment < 0)) { + const auto target_state = std::min( + curr_cdev_vote + binded_cdev_info_pair.second.max_throttle_step, + cdev_info.max_state); cdev_power_budget = std::max(cdev_power_budget, cdev_info.state2power[target_state]); } @@ -527,6 +575,13 @@ bool ThermalThrottling::throttlingReleaseUpdate( << ": power threshold = " << binded_cdev_info_pair.second.power_thresholds[static_cast<int>(severity)] << ", avg power = " << avg_power; + std::string atrace_prefix = ::android::base::StringPrintf( + "%s-%s", sensor_name.data(), binded_cdev_info_pair.second.power_rail.data()); + ATRACE_INT( + (atrace_prefix + std::string("-power_threshold")).c_str(), + static_cast<int>( + binded_cdev_info_pair.second.power_thresholds[static_cast<int>(severity)])); + ATRACE_INT((atrace_prefix + std::string("-avg_power")).c_str(), avg_power); switch (binded_cdev_info_pair.second.release_logic) { case ReleaseLogic::INCREASE: @@ -570,7 +625,7 @@ bool ThermalThrottling::throttlingReleaseUpdate( } void ThermalThrottling::thermalThrottlingUpdate( - const Temperature_2_0 &temp, const SensorInfo &sensor_info, + const Temperature &temp, const SensorInfo &sensor_info, const ThrottlingSeverity curr_severity, const std::chrono::milliseconds time_elapsed_ms, const std::unordered_map<std::string, PowerStatus> &power_status_map, const std::unordered_map<std::string, CdevInfo> &cooling_device_info_map) { @@ -603,8 +658,8 @@ void ThermalThrottling::thermalThrottlingUpdate( void ThermalThrottling::computeCoolingDevicesRequest( std::string_view sensor_name, const SensorInfo &sensor_info, - const ThrottlingSeverity curr_severity, - std::vector<std::string> *cooling_devices_to_update) { + const ThrottlingSeverity curr_severity, std::vector<std::string> *cooling_devices_to_update, + ThermalStatsHelper *thermal_stats_helper) { int release_step = 0; std::unique_lock<std::shared_mutex> _lock(thermal_throttling_status_map_mutex_); @@ -618,33 +673,41 @@ void ThermalThrottling::computeCoolingDevicesRequest( for (auto &cdev_request_pair : thermal_throttling_status.cdev_status_map) { int pid_cdev_request = 0; int hardlimit_cdev_request = 0; + const auto &cdev_name = cdev_request_pair.first; const auto &binded_cdev_info = - sensor_info.throttling_info->binded_cdev_info_map.at(cdev_request_pair.first); + sensor_info.throttling_info->binded_cdev_info_map.at(cdev_name); const auto cdev_ceiling = binded_cdev_info.cdev_ceiling[static_cast<size_t>(curr_severity)]; const auto cdev_floor = binded_cdev_info.cdev_floor_with_power_link[static_cast<size_t>(curr_severity)]; release_step = 0; - if (thermal_throttling_status.pid_cdev_request_map.count(cdev_request_pair.first)) { - pid_cdev_request = - thermal_throttling_status.pid_cdev_request_map.at(cdev_request_pair.first); + if (thermal_throttling_status.pid_cdev_request_map.count(cdev_name)) { + pid_cdev_request = thermal_throttling_status.pid_cdev_request_map.at(cdev_name); } - if (thermal_throttling_status.hardlimit_cdev_request_map.count(cdev_request_pair.first)) { - hardlimit_cdev_request = thermal_throttling_status.hardlimit_cdev_request_map.at( - cdev_request_pair.first); + if (thermal_throttling_status.hardlimit_cdev_request_map.count(cdev_name)) { + hardlimit_cdev_request = + thermal_throttling_status.hardlimit_cdev_request_map.at(cdev_name); } - if (cdev_release_map.count(cdev_request_pair.first)) { - release_step = cdev_release_map.at(cdev_request_pair.first); + if (cdev_release_map.count(cdev_name)) { + release_step = cdev_release_map.at(cdev_name); } - LOG(VERBOSE) << sensor_name.data() << " binded cooling device " << cdev_request_pair.first + LOG(VERBOSE) << sensor_name.data() << " binded cooling device " << cdev_name << "'s pid_request=" << pid_cdev_request << " hardlimit_cdev_request=" << hardlimit_cdev_request << " release_step=" << release_step << " cdev_floor_with_power_link=" << cdev_floor << " cdev_ceiling=" << cdev_ceiling; + std::string atrace_prefix = + ::android::base::StringPrintf("%s-%s", sensor_name.data(), cdev_name.data()); + ATRACE_INT((atrace_prefix + std::string("-pid_request")).c_str(), pid_cdev_request); + ATRACE_INT((atrace_prefix + std::string("-hardlimit_request")).c_str(), + hardlimit_cdev_request); + ATRACE_INT((atrace_prefix + std::string("-release_step")).c_str(), release_step); + ATRACE_INT((atrace_prefix + std::string("-cdev_floor")).c_str(), cdev_floor); + ATRACE_INT((atrace_prefix + std::string("-cdev_ceiling")).c_str(), cdev_ceiling); auto request_state = std::max(pid_cdev_request, hardlimit_cdev_request); if (release_step) { @@ -657,16 +720,48 @@ void ThermalThrottling::computeCoolingDevicesRequest( request_state = std::max(request_state, cdev_floor); } request_state = std::min(request_state, cdev_ceiling); - if (cdev_request_pair.second != request_state) { + if (updateCdevMaxRequestAndNotifyIfChange(cdev_name, cdev_request_pair.second, + request_state)) { + cooling_devices_to_update->emplace_back(cdev_name); + } cdev_request_pair.second = request_state; - cooling_devices_to_update->emplace_back(cdev_request_pair.first); + // Update sensor cdev request time in state + thermal_stats_helper->updateSensorCdevRequestStats(sensor_name, cdev_name, + cdev_request_pair.second); } } } +bool ThermalThrottling::updateCdevMaxRequestAndNotifyIfChange(std::string_view cdev_name, + int cur_request, int new_request) { + std::unique_lock<std::shared_mutex> _lock(cdev_all_request_map_mutex_); + auto &request_set = cdev_all_request_map_.at(cdev_name.data()); + int cur_max_request = (*request_set.begin()); + // Remove old cdev request and add the new one. + request_set.erase(request_set.find(cur_request)); + request_set.insert(new_request); + // Check if there is any change in aggregated max cdev request. + int new_max_request = (*request_set.begin()); + LOG(VERBOSE) << "For cooling device [" << cdev_name.data() + << "] cur_max_request is: " << cur_max_request + << " new_max_request is: " << new_max_request; + return new_max_request != cur_max_request; +} + +bool ThermalThrottling::getCdevMaxRequest(std::string_view cdev_name, int *max_state) { + std::shared_lock<std::shared_mutex> _lock(cdev_all_request_map_mutex_); + if (!cdev_all_request_map_.count(cdev_name.data())) { + LOG(ERROR) << "Cooling device [" << cdev_name.data() + << "] not present in cooling device request map"; + return false; + } + *max_state = *cdev_all_request_map_.at(cdev_name.data()).begin(); + return true; +} + } // namespace implementation -} // namespace V2_0 } // namespace thermal } // namespace hardware } // namespace android +} // namespace aidl diff --git a/thermal/utils/thermal_throttling.h b/thermal/utils/thermal_throttling.h index d373dd36..e83ee06a 100644 --- a/thermal/utils/thermal_throttling.h +++ b/thermal/utils/thermal_throttling.h @@ -16,9 +16,10 @@ #pragma once -#include <android/hardware/thermal/2.0/IThermal.h> +#include <aidl/android/hardware/thermal/Temperature.h> #include <queue> +#include <set> #include <shared_mutex> #include <string> #include <unordered_map> @@ -26,19 +27,14 @@ #include "power_files.h" #include "thermal_info.h" +#include "thermal_stats_helper.h" +namespace aidl { namespace android { namespace hardware { namespace thermal { -namespace V2_0 { namespace implementation { -using ::android::hardware::hidl_vec; -using ::android::hardware::thermal::V2_0::IThermal; -using Temperature_2_0 = ::android::hardware::thermal::V2_0::Temperature; -using ::android::hardware::thermal::V2_0::TemperatureThreshold; -using ::android::hardware::thermal::V2_0::ThrottlingSeverity; - struct ThermalThrottlingStatus { std::unordered_map<std::string, int> pid_power_budget_map; std::unordered_map<std::string, int> pid_cdev_request_map; @@ -82,7 +78,7 @@ class ThermalThrottling { } // Update thermal throttling request for the specific sensor void thermalThrottlingUpdate( - const Temperature_2_0 &temp, const SensorInfo &sensor_info, + const Temperature &temp, const SensorInfo &sensor_info, const ThrottlingSeverity curr_severity, const std::chrono::milliseconds time_elapsed_ms, const std::unordered_map<std::string, PowerStatus> &power_status_map, const std::unordered_map<std::string, CdevInfo> &cooling_device_info_map); @@ -90,11 +86,14 @@ class ThermalThrottling { // Compute the throttling target from all the sensors' request void computeCoolingDevicesRequest(std::string_view sensor_name, const SensorInfo &sensor_info, const ThrottlingSeverity curr_severity, - std::vector<std::string> *cooling_devices_to_update); + std::vector<std::string> *cooling_devices_to_update, + ThermalStatsHelper *thermal_stats_helper); + // Get the aggregated (from all sensor) max request for a cooling device + bool getCdevMaxRequest(std::string_view cdev_name, int *max_state); private: // PID algo - get the total power budget - float updatePowerBudget(const Temperature_2_0 &temp, const SensorInfo &sensor_info, + float updatePowerBudget(const Temperature &temp, const SensorInfo &sensor_info, std::chrono::milliseconds time_elapsed_ms, ThrottlingSeverity curr_severity); @@ -102,11 +101,11 @@ class ThermalThrottling { float computeExcludedPower(const SensorInfo &sensor_info, const ThrottlingSeverity curr_severity, const std::unordered_map<std::string, PowerStatus> &power_status_map, - std::string *log_buf); + std::string *log_buf, std::string_view sensor_name); // PID algo - allocate the power to target CDEV according to the ODPM bool allocatePowerToCdev( - const Temperature_2_0 &temp, const SensorInfo &sensor_info, + const Temperature &temp, const SensorInfo &sensor_info, const ThrottlingSeverity curr_severity, const std::chrono::milliseconds time_elapsed_ms, const std::unordered_map<std::string, PowerStatus> &power_status_map, const std::unordered_map<std::string, CdevInfo> &cooling_device_info_map); @@ -124,15 +123,20 @@ class ThermalThrottling { const std::unordered_map<std::string, CdevInfo> &cooling_device_info_map, const std::unordered_map<std::string, PowerStatus> &power_status_map, const ThrottlingSeverity severity, const SensorInfo &sensor_info); - + // Update the cooling device request set for new request and notify the caller if there is + // change in max_request for the cooling device. + bool updateCdevMaxRequestAndNotifyIfChange(std::string_view cdev_name, int cur_request, + int new_request); mutable std::shared_mutex thermal_throttling_status_map_mutex_; // Thermal throttling status from each sensor std::unordered_map<std::string, ThermalThrottlingStatus> thermal_throttling_status_map_; - std::vector<std::string> cooling_devices_to_update; + std::shared_mutex cdev_all_request_map_mutex_; + // Set of all request for a cooling device from each sensor + std::unordered_map<std::string, std::multiset<int, std::greater<int>>> cdev_all_request_map_; }; } // namespace implementation -} // namespace V2_0 } // namespace thermal } // namespace hardware } // namespace android +} // namespace aidl diff --git a/thermal/utils/thermal_watcher.cpp b/thermal/utils/thermal_watcher.cpp index 6b3b5585..d8bc92e1 100644 --- a/thermal/utils/thermal_watcher.cpp +++ b/thermal/utils/thermal_watcher.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2018 The Android Open Source Project + * Copyright (C) 2022 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. @@ -34,12 +34,12 @@ #include <chrono> #include <fstream> -#include "thermal-helper.h" +#include "../thermal-helper.h" +namespace aidl { namespace android { namespace hardware { namespace thermal { -namespace V2_0 { namespace implementation { namespace { @@ -353,7 +353,7 @@ void ThermalWatcher::registerFilesToWatch(const std::set<std::string> &sensors_t fcntl(uevent_fd_, F_SETFL, O_NONBLOCK); - looper_->addFd(uevent_fd_.get(), 0, Looper::EVENT_INPUT, nullptr, nullptr); + looper_->addFd(uevent_fd_.get(), 0, ::android::Looper::EVENT_INPUT, nullptr, nullptr); sleep_ms_ = std::chrono::milliseconds(0); last_update_time_ = boot_clock::now(); } @@ -394,15 +394,15 @@ void ThermalWatcher::registerFilesToWatchNl(const std::set<std::string> &sensors */ fcntl(thermal_genl_fd_, F_SETFL, O_NONBLOCK); - looper_->addFd(thermal_genl_fd_.get(), 0, Looper::EVENT_INPUT, nullptr, nullptr); + looper_->addFd(thermal_genl_fd_.get(), 0, ::android::Looper::EVENT_INPUT, nullptr, nullptr); sleep_ms_ = std::chrono::milliseconds(0); last_update_time_ = boot_clock::now(); } bool ThermalWatcher::startWatchingDeviceFiles() { if (cb_) { - auto ret = this->run("FileWatcherThread", PRIORITY_HIGHEST); - if (ret != NO_ERROR) { + auto ret = this->run("FileWatcherThread", ::android::PRIORITY_HIGHEST); + if (ret != ::android::NO_ERROR) { LOG(ERROR) << "ThermalWatcherThread start fail"; return false; } else { @@ -440,7 +440,7 @@ void ThermalWatcher::parseUevent(std::set<std::string> *sensors_set) { std::string uevent = cp; auto findSubSystemThermal = uevent.find("SUBSYSTEM=thermal"); if (!thermal_event) { - if (!uevent.find("SUBSYSTEM=")) { + if (::android::base::StartsWith(uevent, "SUBSYSTEM=")) { if (findSubSystemThermal != std::string::npos) { thermal_event = true; } else { @@ -452,8 +452,7 @@ void ThermalWatcher::parseUevent(std::set<std::string> *sensors_set) { if (start_pos != std::string::npos) { start_pos += 5; std::string name = uevent.substr(start_pos); - if (std::find(monitored_sensors_.begin(), monitored_sensors_.end(), name) != - monitored_sensors_.end()) { + if (monitored_sensors_.find(name) != monitored_sensors_.end()) { sensors_set->insert(name); } break; @@ -487,8 +486,7 @@ void ThermalWatcher::parseGenlink(std::set<std::string> *sensors_set) { std::string name; if (getThermalZoneTypeById(tz_id, &name) && - std::find(monitored_sensors_.begin(), monitored_sensors_.end(), name) != - monitored_sensors_.end()) { + monitored_sensors_.find(name) != monitored_sensors_.end()) { sensors_set->insert(name); } } @@ -529,7 +527,7 @@ bool ThermalWatcher::threadLoop() { } } // namespace implementation -} // namespace V2_0 } // namespace thermal } // namespace hardware } // namespace android +} // namespace aidl diff --git a/thermal/utils/thermal_watcher.h b/thermal/utils/thermal_watcher.h index a7e3820f..8f8b3981 100644 --- a/thermal/utils/thermal_watcher.h +++ b/thermal/utils/thermal_watcher.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2018 The Android Open Source Project + * Copyright (C) 2022 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. @@ -35,21 +35,21 @@ #include <unordered_map> #include <vector> +namespace aidl { namespace android { namespace hardware { namespace thermal { -namespace V2_0 { namespace implementation { -using android::base::boot_clock; -using android::base::unique_fd; +using ::android::base::boot_clock; +using ::android::base::unique_fd; using WatcherCallback = std::function<std::chrono::milliseconds(const std::set<std::string> &name)>; // A helper class for monitoring thermal files changes. class ThermalWatcher : public ::android::Thread { public: explicit ThermalWatcher(const WatcherCallback &cb) - : Thread(false), cb_(cb), looper_(new Looper(true)) {} + : Thread(false), cb_(cb), looper_(new ::android::Looper(true)) {} ~ThermalWatcher() = default; // Disallow copy and assign. @@ -91,12 +91,12 @@ class ThermalWatcher : public ::android::Thread { // Callback will return thermal trigger status for next polling decision. const WatcherCallback cb_; - sp<Looper> looper_; + ::android::sp<::android::Looper> looper_; // For uevent socket registration. - android::base::unique_fd uevent_fd_; + ::android::base::unique_fd uevent_fd_; // For thermal genl socket registration. - android::base::unique_fd thermal_genl_fd_; + ::android::base::unique_fd thermal_genl_fd_; // Sensor list which monitor flag is enabled. std::set<std::string> monitored_sensors_; // Sleep interval voting result @@ -108,7 +108,7 @@ class ThermalWatcher : public ::android::Thread { }; } // namespace implementation -} // namespace V2_0 } // namespace thermal } // namespace hardware } // namespace android +} // namespace aidl diff --git a/usb/Android.bp b/usb/Android.bp index 8927c8a2..6fec9965 100644 --- a/usb/Android.bp +++ b/usb/Android.bp @@ -21,12 +21,16 @@ package { cc_library_static { name: "libpixelusb", vendor_available: true, - export_include_dirs: ["include"], + export_include_dirs: [ + "hidl/include", + "include", + ], srcs: [ - "UsbGadgetUtils.cpp", + "hidl/UsbGadgetUtils.cpp", + "UsbOverheatEvent.cpp", + "CommonUtils.cpp", "MonitorFfs.cpp", - "UsbOverheatEvent.cpp" ], cflags: [ @@ -40,10 +44,52 @@ cc_library_static { "libcutils", "libhidlbase", "libutils", + "libbinder_ndk", "android.hardware.usb.gadget@1.0", "android.hardware.thermal@1.0", "android.hardware.thermal@2.0", + "android.hardware.thermal-V1-ndk" + ], + + static_libs: [ + "libthermalutils", + ] +} + +cc_library_static { + name: "libpixelusb-aidl", + vendor_available: true, + export_include_dirs: [ + "aidl/include", + "include", + ], + + srcs: [ + "aidl/UsbGadgetAidlUtils.cpp", + "UsbOverheatEvent.cpp", + "CommonUtils.cpp", + "MonitorFfs.cpp", + ], + + cflags: [ + "-Wall", + "-Werror", + ], + + shared_libs: [ + "libbase", + "libbinder", + "libcutils", + "libutils", + "android.hardware.usb.gadget-V1-ndk", + "android.hardware.thermal@1.0", + "android.hardware.thermal@2.0", + "android.hardware.thermal-V1-ndk" ], + + static_libs: [ + "libthermalutils", + ] } cc_fuzz { diff --git a/usb/CommonUtils.cpp b/usb/CommonUtils.cpp new file mode 100644 index 00000000..3a396d7e --- /dev/null +++ b/usb/CommonUtils.cpp @@ -0,0 +1,161 @@ +/* + * Copyright (C) 2023 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 "libpixelusb-common" + +#include "include/pixelusb/CommonUtils.h" + +#include <android-base/file.h> +#include <android-base/properties.h> +#include <sys/epoll.h> +#include <sys/eventfd.h> +#include <sys/inotify.h> +#include <utils/Log.h> + +#include <chrono> +#include <memory> +#include <mutex> + +namespace android { +namespace hardware { +namespace google { +namespace pixel { +namespace usb { + +using ::android::base::GetProperty; +using ::android::base::SetProperty; +using ::android::base::WriteStringToFile; +using ::std::chrono::microseconds; +using ::std::chrono::steady_clock; +using ::std::literals::chrono_literals::operator""ms; + +int addEpollFd(const base::unique_fd &epfd, const base::unique_fd &fd) { + struct epoll_event event; + int ret; + + event.data.fd = fd; + event.events = EPOLLIN; + + ret = epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &event); + if (ret) + ALOGE("epoll_ctl error %d", errno); + + return ret; +} + +std::string getVendorFunctions() { + if (GetProperty(kBuildType, "") == "user") + return "user"; + + std::string bootMode = GetProperty(PERSISTENT_BOOT_MODE, ""); + std::string persistVendorFunctions = GetProperty(kPersistentVendorConfig, ""); + std::string vendorFunctions = GetProperty(kVendorConfig, ""); + std::string ret = ""; + + if (vendorFunctions != "") { + ret = vendorFunctions; + } else if (bootMode == "usbradio" || bootMode == "factory" || bootMode == "ffbm-00" || + bootMode == "ffbm-01" || bootMode == "usbuwb") { + if (persistVendorFunctions != "") + ret = persistVendorFunctions; + else + ret = "diag"; + // vendor.usb.config will reflect the current configured functions + SetProperty(kVendorConfig, ret); + } + + return ret; +} + +int unlinkFunctions(const char *path) { + DIR *config = opendir(path); + struct dirent *function; + char filepath[kMaxFilePathLength]; + int ret = 0; + + if (config == NULL) + return -1; + + // d_type does not seems to be supported in /config + // so filtering by name. + while (((function = readdir(config)) != NULL)) { + if ((strstr(function->d_name, FUNCTION_NAME) == NULL)) + continue; + // build the path for each file in the folder. + snprintf(filepath, kMaxFilePathLength, "%s/%s", path, function->d_name); + ret = remove(filepath); + if (ret) { + ALOGE("Unable remove file %s errno:%d", filepath, errno); + break; + } + } + + closedir(config); + return ret; +} + +int linkFunction(const char *function, int index) { + char functionPath[kMaxFilePathLength]; + char link[kMaxFilePathLength]; + + snprintf(functionPath, kMaxFilePathLength, "%s%s", FUNCTIONS_PATH, function); + snprintf(link, kMaxFilePathLength, "%s%d", FUNCTION_PATH, index); + if (symlink(functionPath, link)) { + ALOGE("Cannot create symlink %s -> %s errno:%d", link, functionPath, errno); + return -1; + } + return 0; +} + +bool setVidPidCommon(const char *vid, const char *pid) { + if (!WriteStringToFile(vid, VENDOR_ID_PATH)) + return false; + + if (!WriteStringToFile(pid, PRODUCT_ID_PATH)) + return false; + + return true; +} + +bool resetGadgetCommon() { + ALOGI("setCurrentUsbFunctions None"); + + if (!WriteStringToFile("none", PULLUP_PATH)) + ALOGI("Gadget cannot be pulled down"); + + if (!WriteStringToFile("0", DEVICE_CLASS_PATH)) + return false; + + if (!WriteStringToFile("0", DEVICE_SUB_CLASS_PATH)) + return false; + + if (!WriteStringToFile("0", DEVICE_PROTOCOL_PATH)) + return false; + + if (!WriteStringToFile("0", DESC_USE_PATH)) + return false; + + if (unlinkFunctions(CONFIG_PATH)) + return false; + + return true; +} + +} // namespace usb +} // namespace pixel +} // namespace google +} // namespace hardware +} // namespace android diff --git a/usb/MonitorFfs.cpp b/usb/MonitorFfs.cpp index 717e6a73..d640520a 100644 --- a/usb/MonitorFfs.cpp +++ b/usb/MonitorFfs.cpp @@ -14,9 +14,19 @@ * limitations under the License. */ -#define LOG_TAG "libpixelusb" +#define LOG_TAG "libpixelusb-MonitorFfs" -#include "include/pixelusb/UsbGadgetCommon.h" +#include "include/pixelusb/MonitorFfs.h" + +#include <android-base/file.h> +#include <sys/epoll.h> +#include <sys/eventfd.h> +#include <sys/inotify.h> +#include <utils/Log.h> + +#include <chrono> +#include <memory> +#include <mutex> namespace android { namespace hardware { @@ -24,6 +34,11 @@ namespace google { namespace pixel { namespace usb { +using ::android::base::WriteStringToFile; +using ::std::chrono::microseconds; +using ::std::chrono::steady_clock; +using ::std::literals::chrono_literals::operator""ms; + static volatile bool gadgetPullup; MonitorFfs::MonitorFfs(const char *const gadget) @@ -62,9 +77,9 @@ MonitorFfs::MonitorFfs(const char *const gadget) if (addEpollFd(epollFd, eventFd) == -1) abort(); - mEpollFd = move(epollFd); - mInotifyFd = move(inotifyFd); - mEventFd = move(eventFd); + mEpollFd = std::move(epollFd); + mInotifyFd = std::move(inotifyFd); + mEventFd = std::move(eventFd); gadgetPullup = false; } @@ -130,8 +145,8 @@ void *MonitorFfs::startMonitorFd(void *param) { // notify here if the endpoints are already present. if (descriptorWritten) { usleep(kPullUpDelay); - if (!!WriteStringToFile(monitorFfs->mGadgetName, PULLUP_PATH)) { - lock_guard<mutex> lock(monitorFfs->mLock); + if (WriteStringToFile(monitorFfs->mGadgetName, PULLUP_PATH)) { + std::lock_guard<std::mutex> lock(monitorFfs->mLock); monitorFfs->mCurrentUsbFunctionsApplied = true; monitorFfs->mCallback(monitorFfs->mCurrentUsbFunctionsApplied, monitorFfs->mPayload); gadgetPullup = true; @@ -157,24 +172,27 @@ void *MonitorFfs::startMonitorFd(void *param) { int numRead = read(monitorFfs->mInotifyFd, buf, kBufferSize); for (char *p = buf; p < buf + numRead;) { struct inotify_event *event = (struct inotify_event *)p; - if (kDebug) + if (kDebug) { displayInotifyEvent(event); + } p += sizeof(struct inotify_event) + event->len; bool descriptorPresent = true; for (int j = 0; j < static_cast<int>(monitorFfs->mEndpointList.size()); j++) { if (access(monitorFfs->mEndpointList.at(j).c_str(), R_OK)) { - if (kDebug) + if (kDebug) { ALOGI("%s absent", monitorFfs->mEndpointList.at(j).c_str()); + } descriptorPresent = false; break; } } if (!descriptorPresent && !writeUdc) { - if (kDebug) + if (kDebug) { ALOGI("endpoints not up"); + } writeUdc = true; disconnect = std::chrono::steady_clock::now(); } else if (descriptorPresent && writeUdc) { @@ -184,8 +202,8 @@ void *MonitorFfs::startMonitorFd(void *param) { kPullUpDelay) usleep(kPullUpDelay); - if (!!WriteStringToFile(monitorFfs->mGadgetName, PULLUP_PATH)) { - lock_guard<mutex> lock(monitorFfs->mLock); + if (WriteStringToFile(monitorFfs->mGadgetName, PULLUP_PATH)) { + std::lock_guard<std::mutex> lock(monitorFfs->mLock); monitorFfs->mCurrentUsbFunctionsApplied = true; monitorFfs->mCallback(monitorFfs->mCurrentUsbFunctionsApplied, monitorFfs->mPayload); @@ -211,7 +229,7 @@ void *MonitorFfs::startMonitorFd(void *param) { } void MonitorFfs::reset() { - lock_guard<mutex> lock(mLockFd); + std::lock_guard<std::mutex> lock(mLockFd); uint64_t flag = 100; unsigned long ret; @@ -237,7 +255,7 @@ void MonitorFfs::reset() { } bool MonitorFfs::startMonitor() { - mMonitor = unique_ptr<thread>(new thread(this->startMonitorFd, this)); + mMonitor = std::make_unique<std::thread>(this->startMonitorFd, this); mMonitorRunning = true; return true; } @@ -263,8 +281,8 @@ bool MonitorFfs::waitForPullUp(int timeout_ms) { } } -bool MonitorFfs::addInotifyFd(string fd) { - lock_guard<mutex> lock(mLockFd); +bool MonitorFfs::addInotifyFd(std::string fd) { + std::lock_guard<std::mutex> lock(mLockFd); int wfd; wfd = inotify_add_watch(mInotifyFd, fd.c_str(), IN_ALL_EVENTS); @@ -276,8 +294,8 @@ bool MonitorFfs::addInotifyFd(string fd) { return true; } -void MonitorFfs::addEndPoint(string ep) { - lock_guard<mutex> lock(mLockFd); +void MonitorFfs::addEndPoint(std::string ep) { + std::lock_guard<std::mutex> lock(mLockFd); mEndpointList.push_back(ep); } diff --git a/usb/UsbGadgetUtils_fuzz.cpp b/usb/UsbGadgetUtils_fuzz.cpp index b79da69b..8215ecb6 100644 --- a/usb/UsbGadgetUtils_fuzz.cpp +++ b/usb/UsbGadgetUtils_fuzz.cpp @@ -2,7 +2,7 @@ #include <stdint.h> #include "fuzzer/FuzzedDataProvider.h" -#include "include/pixelusb/UsbGadgetCommon.h" +#include "hidl/include/pixelusb/UsbGadgetCommon.h" using ::android::hardware::google::pixel::usb::setVidPid; diff --git a/usb/UsbOverheatEvent.cpp b/usb/UsbOverheatEvent.cpp index a80f8b22..4911faaf 100644 --- a/usb/UsbOverheatEvent.cpp +++ b/usb/UsbOverheatEvent.cpp @@ -18,6 +18,9 @@ #include "include/pixelusb/UsbOverheatEvent.h" +#include <aidl/android/hardware/thermal/IThermal.h> +#include <android/binder_manager.h> +#include <thermalutils/ThermalHidlWrapper.h> #include <time.h> namespace android { @@ -35,7 +38,7 @@ constexpr char kWakeLockPath[] = "/sys/power/wake_lock"; constexpr char kWakeUnlockPath[] = "/sys/power/wake_unlock"; int addEpollFdWakeUp(const unique_fd &epfd, const unique_fd &fd) { - struct epoll_event event; + struct epoll_event event {}; int ret; event.data.fd = fd; @@ -88,14 +91,18 @@ UsbOverheatEvent::UsbOverheatEvent(const ZoneInfo &monitored_zone, abort(); } - epoll_fd_ = move(epollFd); - timer_fd_ = move(timerFd); - event_fd_ = move(eventFd); + epoll_fd_ = std::move(epollFd); + timer_fd_ = std::move(timerFd); + event_fd_ = std::move(eventFd); monitor_ = unique_ptr<thread>(new thread(this->monitorThread, this)); registerListener(); } +UsbOverheatEvent::~UsbOverheatEvent() { + unregisterThermalCallback(); +} + static int wakelock_cnt = 0; static std::mutex wakelock_lock; @@ -124,7 +131,7 @@ static void wakeLockRelease() { } void *UsbOverheatEvent::monitorThread(void *param) { - UsbOverheatEvent *overheatEvent = (UsbOverheatEvent *)param; + auto *overheatEvent = reinterpret_cast<UsbOverheatEvent *>(param); struct epoll_event events[kEpollEvents]; struct itimerspec delay = itimerspec(); @@ -180,12 +187,15 @@ void *UsbOverheatEvent::monitorThread(void *param) { } } } - - return NULL; } bool UsbOverheatEvent::registerListener() { ALOGV("UsbOverheatEvent::registerListener"); + const std::lock_guard<std::mutex> lock(thermal_hal_mutex_); + if (connectAidlThermalService()) { + return true; + } + sp<IServiceManager> sm = IServiceManager::getService(); if (sm == NULL) { ALOGE("Hardware service manager is not running"); @@ -193,6 +203,7 @@ bool UsbOverheatEvent::registerListener() { } Return<bool> result = sm->registerForNotifications(IThermal::descriptor, "", this); if (result.isOk()) { + ALOGI("Thermal HIDL service connected!"); return true; } ALOGE("Failed to register for hardware service manager notifications: %s", @@ -200,6 +211,47 @@ bool UsbOverheatEvent::registerListener() { return false; } +bool UsbOverheatEvent::connectAidlThermalService() { + const std::string thermal_instance_name = + std::string(::aidl::android::hardware::thermal::IThermal::descriptor) + "/default"; + if (AServiceManager_isDeclared(thermal_instance_name.c_str())) { + auto thermal_aidl_service = ::aidl::android::hardware::thermal::IThermal::fromBinder( + ndk::SpAIBinder(AServiceManager_waitForService(thermal_instance_name.c_str()))); + if (thermal_aidl_service) { + thermal_service_ = sp<::aidl::android::hardware::thermal::ThermalHidlWrapper>::make( + thermal_aidl_service); + if (thermal_aidl_death_recipient_.get() == nullptr) { + thermal_aidl_death_recipient_ = ndk::ScopedAIBinder_DeathRecipient( + AIBinder_DeathRecipient_new(onThermalAidlBinderDied)); + } + auto linked = AIBinder_linkToDeath(thermal_aidl_service->asBinder().get(), + thermal_aidl_death_recipient_.get(), this); + if (linked != STATUS_OK) { + ALOGE("Failed to register AIDL thermal death recipient"); + } + is_thermal_callback_registered_ = registerThermalCallback("AIDL"); + return is_thermal_callback_registered_; + } else { + ALOGE("Unable to get Thermal AIDL service"); + } + } else { + ALOGW("Thermal AIDL service is not declared"); + } + return false; +} + +void UsbOverheatEvent::unregisterThermalCallback() { + const std::lock_guard<std::mutex> lock(thermal_hal_mutex_); + if (is_thermal_callback_registered_) { + ThermalStatus returnStatus; + auto ret = thermal_service_->unregisterThermalChangedCallback( + this, [&returnStatus](ThermalStatus status) { returnStatus = status; }); + if (!ret.isOk() || returnStatus.code != ThermalStatusCode::SUCCESS) { + ALOGE("Failed to unregister thermal callback"); + } + } +} + void UsbOverheatEvent::wakeupMonitor() { // <flag> value does not have any significance here uint64_t flag = 100; @@ -238,7 +290,7 @@ bool UsbOverheatEvent::stopRecording() { bool UsbOverheatEvent::getCurrentTemperature(const string &name, float *temp) { ThermalStatus thermal_status; hidl_vec<Temperature> thermal_temperatures; - + const std::lock_guard<std::mutex> lock(thermal_hal_mutex_); if (thermal_service_ == NULL) return false; @@ -268,22 +320,27 @@ Return<void> UsbOverheatEvent::onRegistration(const hidl_string & /*fully_qualif const hidl_string & /*instance_name*/, bool /*pre_existing*/) { ThermalStatus thermal_status; - + const std::lock_guard<std::mutex> lock(thermal_hal_mutex_); thermal_service_ = IThermal::getService(); if (thermal_service_ == NULL) { - ALOGE("Unable to get Themal Service"); + ALOGE("Unable to get Themal HIDL Service"); return Void(); } + is_thermal_callback_registered_ = registerThermalCallback("HIDL"); + return Void(); +} +bool UsbOverheatEvent::registerThermalCallback(const string &service_str) { + ThermalStatus thermal_status; auto ret = thermal_service_->registerThermalChangedCallback( this, true, monitored_zone_.type_, [&](ThermalStatus status) { thermal_status = status; }); if (!ret.isOk() || thermal_status.code != ThermalStatusCode::SUCCESS) { - ALOGE("failed to register thermal changed callback!"); + ALOGE("Failed to register thermal changed callback using %s client", service_str.c_str()); + return false; } - - return Void(); + return true; } Return<void> UsbOverheatEvent::notifyThrottling(const Temperature &temperature) { diff --git a/usb/aidl/UsbGadgetAidlUtils.cpp b/usb/aidl/UsbGadgetAidlUtils.cpp new file mode 100644 index 00000000..fa9983fa --- /dev/null +++ b/usb/aidl/UsbGadgetAidlUtils.cpp @@ -0,0 +1,149 @@ +/* + * Copyright (C) 2023 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 "libpixelusb-aidl" + +#include <aidl/android/hardware/usb/gadget/GadgetFunction.h> +#include <android-base/file.h> +#include <android-base/properties.h> +#include <utils/Log.h> + +#include "aidl/include/pixelusb/UsbGadgetAidlCommon.h" + +namespace android { +namespace hardware { +namespace google { +namespace pixel { +namespace usb { + +using ::aidl::android::hardware::usb::gadget::GadgetFunction; +using ::android::base::GetBoolProperty; +using ::android::base::GetProperty; +using ::android::base::SetProperty; +using ::android::base::WriteStringToFile; + +Status setVidPid(const char *vid, const char *pid) { + return setVidPidCommon(vid, pid) ? Status::SUCCESS : Status::ERROR; +} + +Status resetGadget() { + return resetGadgetCommon() ? Status::SUCCESS : Status::ERROR; +} + +Status addGenericAndroidFunctions(MonitorFfs *monitorFfs, uint64_t functions, bool *ffsEnabled, + int *functionCount) { + if (((functions & GadgetFunction::MTP) != 0)) { + *ffsEnabled = true; + ALOGI("setCurrentUsbFunctions mtp"); + if (!WriteStringToFile("1", DESC_USE_PATH)) + return Status::ERROR; + + if (!monitorFfs->addInotifyFd("/dev/usb-ffs/mtp/")) + return Status::ERROR; + + if (linkFunction("ffs.mtp", (*functionCount)++)) + return Status::ERROR; + + // Add endpoints to be monitored. + monitorFfs->addEndPoint("/dev/usb-ffs/mtp/ep1"); + monitorFfs->addEndPoint("/dev/usb-ffs/mtp/ep2"); + monitorFfs->addEndPoint("/dev/usb-ffs/mtp/ep3"); + } else if (((functions & GadgetFunction::PTP) != 0)) { + *ffsEnabled = true; + ALOGI("setCurrentUsbFunctions ptp"); + if (!WriteStringToFile("1", DESC_USE_PATH)) + return Status::ERROR; + + if (!monitorFfs->addInotifyFd("/dev/usb-ffs/ptp/")) + return Status::ERROR; + + if (linkFunction("ffs.ptp", (*functionCount)++)) + return Status::ERROR; + + // Add endpoints to be monitored. + monitorFfs->addEndPoint("/dev/usb-ffs/ptp/ep1"); + monitorFfs->addEndPoint("/dev/usb-ffs/ptp/ep2"); + monitorFfs->addEndPoint("/dev/usb-ffs/ptp/ep3"); + } + + if ((functions & GadgetFunction::MIDI) != 0) { + ALOGI("setCurrentUsbFunctions MIDI"); + if (linkFunction("midi.gs5", (*functionCount)++)) + return Status::ERROR; + } + + if ((functions & GadgetFunction::ACCESSORY) != 0) { + ALOGI("setCurrentUsbFunctions Accessory"); + if (linkFunction("accessory.gs2", (*functionCount)++)) + return Status::ERROR; + } + + if ((functions & GadgetFunction::AUDIO_SOURCE) != 0) { + ALOGI("setCurrentUsbFunctions Audio Source"); + if (linkFunction("audio_source.gs3", (*functionCount)++)) + return Status::ERROR; + } + + if ((functions & GadgetFunction::RNDIS) != 0) { + ALOGI("setCurrentUsbFunctions rndis"); + std::string rndisFunction = GetProperty(kVendorRndisConfig, ""); + if (rndisFunction != "") { + if (linkFunction(rndisFunction.c_str(), (*functionCount)++)) + return Status::ERROR; + } else { + // link gsi.rndis for older pixel projects + if (linkFunction("gsi.rndis", (*functionCount)++)) + return Status::ERROR; + } + } + + if ((functions & GadgetFunction::UVC) != 0) { + if (!GetBoolProperty(kUvcEnabled, false)) { + ALOGE("UVC function disabled by config"); + return Status::ERROR; + } + + ALOGI("setCurrentUsbFunctions uvc"); + if (linkFunction("uvc.0", (*functionCount)++)) { + return Status::ERROR; + } + } + + return Status::SUCCESS; +} + +Status addAdb(MonitorFfs *monitorFfs, int *functionCount) { + ALOGI("setCurrentUsbFunctions Adb"); + if (!WriteStringToFile("1", DESC_USE_PATH)) + return Status::ERROR; + + if (!monitorFfs->addInotifyFd("/dev/usb-ffs/adb/")) + return Status::ERROR; + + if (linkFunction("ffs.adb", (*functionCount)++)) + return Status::ERROR; + + monitorFfs->addEndPoint("/dev/usb-ffs/adb/ep1"); + monitorFfs->addEndPoint("/dev/usb-ffs/adb/ep2"); + ALOGI("Service started"); + return Status::SUCCESS; +} + +} // namespace usb +} // namespace pixel +} // namespace google +} // namespace hardware +} // namespace android diff --git a/usb/aidl/include/pixelusb/UsbGadgetAidlCommon.h b/usb/aidl/include/pixelusb/UsbGadgetAidlCommon.h new file mode 100644 index 00000000..5afec5e4 --- /dev/null +++ b/usb/aidl/include/pixelusb/UsbGadgetAidlCommon.h @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2023 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. + */ + +#ifndef HARDWARE_GOOGLE_PIXEL_USB_USBGADGETAIDLCOMMON_H +#define HARDWARE_GOOGLE_PIXEL_USB_USBGADGETAIDLCOMMON_H + +#include <aidl/android/hardware/usb/gadget/IUsbGadget.h> +#include <pixelusb/CommonUtils.h> +#include <pixelusb/MonitorFfs.h> + +namespace android { +namespace hardware { +namespace google { +namespace pixel { +namespace usb { + +using ::aidl::android::hardware::usb::gadget::Status; + +//**************** Helper functions ************************// +// Sets the USB VID and PID. +Status setVidPid(const char *vid, const char *pid); +// Adds Adb to the usb configuration. +Status addAdb(MonitorFfs *monitorFfs, int *functionCount); +// Adds all applicable generic android usb functions other than ADB. +Status addGenericAndroidFunctions(MonitorFfs *monitorFfs, uint64_t functions, bool *ffsEnabled, + int *functionCount); +// Pulls down USB gadget. +Status resetGadget(); + +} // namespace usb +} // namespace pixel +} // namespace google +} // namespace hardware +} // namespace android +#endif diff --git a/usb/UsbGadgetUtils.cpp b/usb/hidl/UsbGadgetUtils.cpp index 7da4b784..7084586b 100644 --- a/usb/UsbGadgetUtils.cpp +++ b/usb/hidl/UsbGadgetUtils.cpp @@ -14,9 +14,13 @@ * limitations under the License. */ -#define LOG_TAG "libpixelusb" +#define LOG_TAG "libpixelusb-hidl" -#include "include/pixelusb/UsbGadgetCommon.h" +#include <android-base/file.h> +#include <android-base/properties.h> +#include <utils/Log.h> + +#include "hidl/include/pixelusb/UsbGadgetCommon.h" namespace android { namespace hardware { @@ -24,116 +28,17 @@ namespace google { namespace pixel { namespace usb { -int unlinkFunctions(const char *path) { - DIR *config = opendir(path); - struct dirent *function; - char filepath[kMaxFilePathLength]; - int ret = 0; - - if (config == NULL) - return -1; - - // d_type does not seems to be supported in /config - // so filtering by name. - while (((function = readdir(config)) != NULL)) { - if ((strstr(function->d_name, FUNCTION_NAME) == NULL)) - continue; - // build the path for each file in the folder. - snprintf(filepath, kMaxFilePathLength, "%s/%s", path, function->d_name); - ret = remove(filepath); - if (ret) { - ALOGE("Unable remove file %s errno:%d", filepath, errno); - break; - } - } - - closedir(config); - return ret; -} - -int addEpollFd(const unique_fd &epfd, const unique_fd &fd) { - struct epoll_event event; - int ret; - - event.data.fd = fd; - event.events = EPOLLIN; - - ret = epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &event); - if (ret) - ALOGE("epoll_ctl error %d", errno); - - return ret; -} - -int linkFunction(const char *function, int index) { - char functionPath[kMaxFilePathLength]; - char link[kMaxFilePathLength]; - - snprintf(functionPath, kMaxFilePathLength, "%s%s", FUNCTIONS_PATH, function); - snprintf(link, kMaxFilePathLength, "%s%d", FUNCTION_PATH, index); - if (symlink(functionPath, link)) { - ALOGE("Cannot create symlink %s -> %s errno:%d", link, functionPath, errno); - return -1; - } - return 0; -} +using ::android::base::GetProperty; +using ::android::base::SetProperty; +using ::android::base::WriteStringToFile; +using ::android::hardware::usb::gadget::V1_0::GadgetFunction; Status setVidPid(const char *vid, const char *pid) { - if (!WriteStringToFile(vid, VENDOR_ID_PATH)) - return Status::ERROR; - - if (!WriteStringToFile(pid, PRODUCT_ID_PATH)) - return Status::ERROR; - - return Status::SUCCESS; -} - -std::string getVendorFunctions() { - if (GetProperty(kBuildType, "") == "user") - return "user"; - - std::string bootMode = GetProperty(PERSISTENT_BOOT_MODE, ""); - std::string persistVendorFunctions = GetProperty(kPersistentVendorConfig, ""); - std::string vendorFunctions = GetProperty(kVendorConfig, ""); - std::string ret = ""; - - if (vendorFunctions != "") { - ret = vendorFunctions; - } else if (bootMode == "usbradio" || bootMode == "factory" || bootMode == "ffbm-00" || - bootMode == "ffbm-01" || bootMode == "usbuwb") { - if (persistVendorFunctions != "") - ret = persistVendorFunctions; - else - ret = "diag"; - // vendor.usb.config will reflect the current configured functions - SetProperty(kVendorConfig, ret); - } - - return ret; + return setVidPidCommon(vid, pid) ? Status::SUCCESS : Status::ERROR; } Status resetGadget() { - ALOGI("setCurrentUsbFunctions None"); - - if (!WriteStringToFile("none", PULLUP_PATH)) - ALOGI("Gadget cannot be pulled down"); - - if (!WriteStringToFile("0", DEVICE_CLASS_PATH)) - return Status::ERROR; - - if (!WriteStringToFile("0", DEVICE_SUB_CLASS_PATH)) - return Status::ERROR; - - if (!WriteStringToFile("0", DEVICE_PROTOCOL_PATH)) - return Status::ERROR; - - if (!WriteStringToFile("0", DESC_USE_PATH)) - return Status::ERROR; - - if (unlinkFunctions(CONFIG_PATH)) - return Status::ERROR; - - return Status::SUCCESS; + return resetGadgetCommon() ? Status::SUCCESS : Status::ERROR; } Status addGenericAndroidFunctions(MonitorFfs *monitorFfs, uint64_t functions, bool *ffsEnabled, @@ -216,6 +121,7 @@ Status addAdb(MonitorFfs *monitorFfs, int *functionCount) { if (linkFunction("ffs.adb", (*functionCount)++)) return Status::ERROR; + monitorFfs->addEndPoint("/dev/usb-ffs/adb/ep1"); monitorFfs->addEndPoint("/dev/usb-ffs/adb/ep2"); ALOGI("Service started"); diff --git a/usb/hidl/include/pixelusb/UsbGadgetCommon.h b/usb/hidl/include/pixelusb/UsbGadgetCommon.h new file mode 100644 index 00000000..3a9818ef --- /dev/null +++ b/usb/hidl/include/pixelusb/UsbGadgetCommon.h @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2018 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. + */ + +#ifndef HARDWARE_GOOGLE_PIXEL_USB_USBGADGETCOMMON_H +#define HARDWARE_GOOGLE_PIXEL_USB_USBGADGETCOMMON_H + +#include <android/hardware/usb/gadget/1.0/IUsbGadget.h> +#include <pixelusb/MonitorFfs.h> + +namespace android { +namespace hardware { +namespace google { +namespace pixel { +namespace usb { + +using ::android::hardware::usb::gadget::V1_0::Status; + +//**************** Helper functions ************************// + +// Sets the USB VID and PID. +Status setVidPid(const char *vid, const char *pid); +// Adds Adb to the usb configuration. +Status addAdb(MonitorFfs *monitorFfs, int *functionCount); +// Adds all applicable generic android usb functions other than ADB. +Status addGenericAndroidFunctions(MonitorFfs *monitorFfs, uint64_t functions, bool *ffsEnabled, + int *functionCount); +// Pulls down USB gadget. +Status resetGadget(); + +} // namespace usb +} // namespace pixel +} // namespace google +} // namespace hardware +} // namespace android +#endif diff --git a/usb/include/pixelusb/CommonUtils.h b/usb/include/pixelusb/CommonUtils.h new file mode 100644 index 00000000..91244f81 --- /dev/null +++ b/usb/include/pixelusb/CommonUtils.h @@ -0,0 +1,78 @@ +/* + * Copyright (C) 2023 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. + */ + +#ifndef HARDWARE_GOOGLE_PIXEL_USB_UTILSCOMMON_H_ +#define HARDWARE_GOOGLE_PIXEL_USB_UTILSCOMMON_H_ + +#include <android-base/unique_fd.h> + +#include <string> + +namespace android { +namespace hardware { +namespace google { +namespace pixel { +namespace usb { + +constexpr int kBufferSize = 512; +constexpr int kMaxFilePathLength = 256; +constexpr int kEpollEvents = 10; +constexpr bool kDebug = false; +constexpr int kDisconnectWaitUs = 100000; +constexpr int kPullUpDelay = 500000; +constexpr int kShutdownMonitor = 100; + +constexpr char kBuildType[] = "ro.build.type"; +constexpr char kPersistentVendorConfig[] = "persist.vendor.usb.usbradio.config"; +constexpr char kVendorConfig[] = "vendor.usb.config"; +constexpr char kVendorRndisConfig[] = "vendor.usb.rndis.config"; +constexpr char kUvcEnabled[] = "ro.usb.uvc.enabled"; + +#define GADGET_PATH "/config/usb_gadget/g1/" +#define PULLUP_PATH GADGET_PATH "UDC" +#define PERSISTENT_BOOT_MODE "ro.bootmode" +#define VENDOR_ID_PATH GADGET_PATH "idVendor" +#define PRODUCT_ID_PATH GADGET_PATH "idProduct" +#define DEVICE_CLASS_PATH GADGET_PATH "bDeviceClass" +#define DEVICE_SUB_CLASS_PATH GADGET_PATH "bDeviceSubClass" +#define DEVICE_PROTOCOL_PATH GADGET_PATH "bDeviceProtocol" +#define DESC_USE_PATH GADGET_PATH "os_desc/use" +#define OS_DESC_PATH GADGET_PATH "os_desc/b.1" +#define CONFIG_PATH GADGET_PATH "configs/b.1/" +#define FUNCTIONS_PATH GADGET_PATH "functions/" +#define FUNCTION_NAME "function" +#define FUNCTION_PATH CONFIG_PATH FUNCTION_NAME +#define RNDIS_PATH FUNCTIONS_PATH "gsi.rndis" + +// Adds the given fd to the epollfd(epfd). +int addEpollFd(const ::android::base::unique_fd &epfd, const ::android::base::unique_fd &fd); +// Extracts vendor functions from the vendor init properties. +std::string getVendorFunctions(); +// Removes all the usb functions link in the specified path. +int unlinkFunctions(const char *path); +// Creates a configfs link for the function. +int linkFunction(const char *function, int index); +// Sets the USB VID and PID. Returns true on success, false on failure +bool setVidPidCommon(const char *vid, const char *pid); +// Pulls down USB gadget. Returns true on success, false on failure +bool resetGadgetCommon(); +} // namespace usb +} // namespace pixel +} // namespace google +} // namespace hardware +} // namespace android + +#endif // HARDWARE_GOOGLE_PIXEL_USB_UTILSCOMMON_H_ diff --git a/usb/include/pixelusb/MonitorFfs.h b/usb/include/pixelusb/MonitorFfs.h new file mode 100644 index 00000000..696134b7 --- /dev/null +++ b/usb/include/pixelusb/MonitorFfs.h @@ -0,0 +1,101 @@ +/* + * Copyright (C) 2022 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. + */ + +#ifndef HARDWARE_GOOGLE_PIXEL_USB_MONITORFFS_H_ +#define HARDWARE_GOOGLE_PIXEL_USB_MONITORFFS_H_ + +#include <android-base/unique_fd.h> +#include <pixelusb/CommonUtils.h> + +#include <mutex> +#include <string> +#include <thread> +#include <vector> + +namespace android { +namespace hardware { +namespace google { +namespace pixel { +namespace usb { + +using ::android::base::unique_fd; + +// MonitorFfs automously manages gadget pullup by monitoring +// the ep file status. Restarts the usb gadget when the ep +// owner restarts. +class MonitorFfs { + private: + // Monitors the endpoints Inotify events. + unique_fd mInotifyFd; + // Control pipe for shutting down the mMonitor thread. + // mMonitor exits when SHUTDOWN_MONITOR is written into + // mEventFd/ + unique_fd mEventFd; + // Pools on mInotifyFd and mEventFd. + unique_fd mEpollFd; + std::vector<int> mWatchFd; + + // Maintains the list of Endpoints. + std::vector<std::string> mEndpointList; + // protects the CV. + std::mutex mLock; + std::condition_variable mCv; + // protects mInotifyFd, mEpollFd. + std::mutex mLockFd; + + // Flag to maintain the current status of gadget pullup. + bool mCurrentUsbFunctionsApplied; + + // Thread object that executes the ep monitoring logic. + std::unique_ptr<std::thread> mMonitor; + // Callback to be invoked when gadget is pulled up. + void (*mCallback)(bool functionsApplied, void *payload); + void *mPayload; + // Name of the USB gadget. Used for pullup. + const char *const mGadgetName; + // Monitor State + bool mMonitorRunning; + + public: + MonitorFfs(const char *const gadget); + // Inits all the UniqueFds. + void reset(); + // Starts monitoring endpoints and pullup the gadget when + // the descriptors are written. + bool startMonitor(); + // Waits for timeout_ms for gadget pull up to happen. + // Returns immediately if the gadget is already pulled up. + bool waitForPullUp(int timeout_ms); + // Adds the given fd to the watch list. + bool addInotifyFd(std::string fd); + // Adds the given endpoint to the watch list. + void addEndPoint(std::string ep); + // Registers the async callback from the caller to notify the caller + // when the gadget pull up happens. + void registerFunctionsAppliedCallback(void (*callback)(bool functionsApplied, void *(payload)), + void *payload); + bool isMonitorRunning(); + // Ep monitoring and the gadget pull up logic. + static void *startMonitorFd(void *param); +}; + +} // namespace usb +} // namespace pixel +} // namespace google +} // namespace hardware +} // namespace android + +#endif // HARDWARE_GOOGLE_PIXEL_USB_MONITORFFS_H_ diff --git a/usb/include/pixelusb/UsbGadgetCommon.h b/usb/include/pixelusb/UsbGadgetCommon.h deleted file mode 100644 index 964a1d6f..00000000 --- a/usb/include/pixelusb/UsbGadgetCommon.h +++ /dev/null @@ -1,181 +0,0 @@ -/* - * Copyright (C) 2018 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. - */ - -#ifndef HARDWARE_GOOGLE_PIXEL_USB_USBGADGETCOMMON_H -#define HARDWARE_GOOGLE_PIXEL_USB_USBGADGETCOMMON_H - -#include <android-base/file.h> -#include <android-base/properties.h> -#include <android-base/unique_fd.h> - -#include <android/hardware/usb/gadget/1.0/IUsbGadget.h> - -#include <dirent.h> -#include <fcntl.h> -#include <stdio.h> -#include <sys/epoll.h> -#include <sys/eventfd.h> -#include <sys/inotify.h> -#include <sys/mount.h> -#include <sys/stat.h> -#include <sys/types.h> -#include <unistd.h> -#include <utils/Log.h> -#include <chrono> -#include <condition_variable> -#include <mutex> -#include <string> -#include <thread> - -namespace android { -namespace hardware { -namespace google { -namespace pixel { -namespace usb { - -constexpr int kBufferSize = 512; -constexpr int kMaxFilePathLength = 256; -constexpr int kEpollEvents = 10; -constexpr bool kDebug = false; -constexpr int kDisconnectWaitUs = 100000; -constexpr int kPullUpDelay = 500000; -constexpr int kShutdownMonitor = 100; - -constexpr char kBuildType[] = "ro.build.type"; -constexpr char kPersistentVendorConfig[] = "persist.vendor.usb.usbradio.config"; -constexpr char kVendorConfig[] = "vendor.usb.config"; -constexpr char kVendorRndisConfig[] = "vendor.usb.rndis.config"; - -#define GADGET_PATH "/config/usb_gadget/g1/" -#define PULLUP_PATH GADGET_PATH "UDC" -#define PERSISTENT_BOOT_MODE "ro.bootmode" -#define VENDOR_ID_PATH GADGET_PATH "idVendor" -#define PRODUCT_ID_PATH GADGET_PATH "idProduct" -#define DEVICE_CLASS_PATH GADGET_PATH "bDeviceClass" -#define DEVICE_SUB_CLASS_PATH GADGET_PATH "bDeviceSubClass" -#define DEVICE_PROTOCOL_PATH GADGET_PATH "bDeviceProtocol" -#define DESC_USE_PATH GADGET_PATH "os_desc/use" -#define OS_DESC_PATH GADGET_PATH "os_desc/b.1" -#define CONFIG_PATH GADGET_PATH "configs/b.1/" -#define FUNCTIONS_PATH GADGET_PATH "functions/" -#define FUNCTION_NAME "function" -#define FUNCTION_PATH CONFIG_PATH FUNCTION_NAME -#define RNDIS_PATH FUNCTIONS_PATH "gsi.rndis" - -using ::android::base::GetProperty; -using ::android::base::SetProperty; -using ::android::base::unique_fd; -using ::android::base::WriteStringToFile; -using ::android::hardware::usb::gadget::V1_0::GadgetFunction; -using ::android::hardware::usb::gadget::V1_0::Status; - -using ::std::lock_guard; -using ::std::move; -using ::std::mutex; -using ::std::string; -using ::std::thread; -using ::std::unique_ptr; -using ::std::vector; -using ::std::chrono::microseconds; -using ::std::chrono::steady_clock; -using ::std::literals::chrono_literals::operator""ms; - -// MonitorFfs automously manages gadget pullup by monitoring -// the ep file status. Restarts the usb gadget when the ep -// owner restarts. -class MonitorFfs { - private: - // Monitors the endpoints Inotify events. - unique_fd mInotifyFd; - // Control pipe for shutting down the mMonitor thread. - // mMonitor exits when SHUTDOWN_MONITOR is written into - // mEventFd/ - unique_fd mEventFd; - // Pools on mInotifyFd and mEventFd. - unique_fd mEpollFd; - vector<int> mWatchFd; - - // Maintains the list of Endpoints. - vector<string> mEndpointList; - // protects the CV. - std::mutex mLock; - std::condition_variable mCv; - // protects mInotifyFd, mEpollFd. - std::mutex mLockFd; - - // Flag to maintain the current status of gadget pullup. - bool mCurrentUsbFunctionsApplied; - - // Thread object that executes the ep monitoring logic. - unique_ptr<thread> mMonitor; - // Callback to be invoked when gadget is pulled up. - void (*mCallback)(bool functionsApplied, void *payload); - void *mPayload; - // Name of the USB gadget. Used for pullup. - const char *const mGadgetName; - // Monitor State - bool mMonitorRunning; - - public: - MonitorFfs(const char *const gadget); - // Inits all the UniqueFds. - void reset(); - // Starts monitoring endpoints and pullup the gadget when - // the descriptors are written. - bool startMonitor(); - // Waits for timeout_ms for gadget pull up to happen. - // Returns immediately if the gadget is already pulled up. - bool waitForPullUp(int timeout_ms); - // Adds the given fd to the watch list. - bool addInotifyFd(string fd); - // Adds the given endpoint to the watch list. - void addEndPoint(string ep); - // Registers the async callback from the caller to notify the caller - // when the gadget pull up happens. - void registerFunctionsAppliedCallback(void (*callback)(bool functionsApplied, - void *(payload)), - void *payload); - bool isMonitorRunning(); - // Ep monitoring and the gadget pull up logic. - static void *startMonitorFd(void *param); -}; - -//**************** Helper functions ************************// - -// Adds the given fd to the epollfd(epfd). -int addEpollFd(const unique_fd &epfd, const unique_fd &fd); -// Removes all the usb functions link in the specified path. -int unlinkFunctions(const char *path); -// Craetes a configfs link for the function. -int linkFunction(const char *function, int index); -// Sets the USB VID and PID. -Status setVidPid(const char *vid, const char *pid); -// Extracts vendor functions from the vendor init properties. -std::string getVendorFunctions(); -// Adds Adb to the usb configuration. -Status addAdb(MonitorFfs *monitorFfs, int *functionCount); -// Adds all applicable generic android usb functions other than ADB. -Status addGenericAndroidFunctions(MonitorFfs *monitorFfs, uint64_t functions, - bool *ffsEnabled, int *functionCount); -// Pulls down USB gadget. -Status resetGadget(); - -} // namespace usb -} // namespace pixel -} // namespace google -} // namespace hardware -} // namespace android -#endif diff --git a/usb/include/pixelusb/UsbOverheatEvent.h b/usb/include/pixelusb/UsbOverheatEvent.h index de8cc240..57f6db58 100644 --- a/usb/include/pixelusb/UsbOverheatEvent.h +++ b/usb/include/pixelusb/UsbOverheatEvent.h @@ -20,6 +20,7 @@ #include <android-base/file.h> #include <android-base/properties.h> #include <android-base/unique_fd.h> +#include <android/binder_auto_utils.h> #include <android/hardware/thermal/2.0/IThermal.h> #include <android/hardware/thermal/2.0/IThermalChangedCallback.h> #include <android/hardware/thermal/2.0/types.h> @@ -82,6 +83,9 @@ class ZoneInfo { ZoneInfo(const TemperatureType &type, const string &name, const ThrottlingSeverity &severity); }; +/** + * TODO: Create an AIDL version of this and move to hidl/ + */ class UsbOverheatEvent : public IServiceNotification, public IThermalChangedCallback { private: // To wake up thread to record max temperature @@ -103,24 +107,44 @@ class UsbOverheatEvent : public IServiceNotification, public IThermalChangedCall unique_ptr<thread> monitor_; // Maximum overheat temperature recorded float max_overheat_temp_; - // Reference to thermal service + // Reference to Thermal service ::android::sp<IThermal> thermal_service_; + // Mutex lock for Thermal service + std::mutex thermal_hal_mutex_; + // Death recipient for Thermal AIDL service + ndk::ScopedAIBinder_DeathRecipient thermal_aidl_death_recipient_; + // Whether the Thermal callback is successfully registered + bool is_thermal_callback_registered_; // Thread that polls temperature to record max temp static void *monitorThread(void *param); // Register service notification listener bool registerListener(); // Helper function to wakeup monitor thread void wakeupMonitor(); - // Thermal ServiceNotification listener + // Thermal HIDL Service Notification listener Return<void> onRegistration(const hidl_string & /*fully_qualified_name*/, const hidl_string & /*instance_name*/, bool /*pre_existing*/) override; // Thermal service callback Return<void> notifyThrottling(const Temperature &temperature) override; + // Register Thermal callback + bool registerThermalCallback(const string &service_str); + // Connect Thermal AIDL service + bool connectAidlThermalService(); + // Unregister Thermal callback + void unregisterThermalCallback(); + // Callback for Thermal AIDL service death recipient + static void onThermalAidlBinderDied(void *cookie) { + if (cookie) { + auto *e = static_cast<UsbOverheatEvent *>(cookie); + e->connectAidlThermalService(); + } + } public: UsbOverheatEvent(const ZoneInfo &monitored_zone, const std::vector<ZoneInfo> &queried_zones, const int &monitor_interval_sec); + ~UsbOverheatEvent(); // Start monitoring thermal zone for maximum temperature bool startRecording(); // Stop monitoring thermal zone diff --git a/vibrator/Android.bp b/vibrator/Android.bp index dff6816c..a06ec3d4 100644 --- a/vibrator/Android.bp +++ b/vibrator/Android.bp @@ -31,6 +31,21 @@ cc_defaults { "liblog", "libutils", ], + tidy: true, + tidy_checks: [ + "-*", + "clang-analyzer-*", + "google-*", + "cert*", + "misc*", + "performance*", + "-google-readability*", + "-misc-const-correctness", + "-misc-non-private-member-variables-in-classes", + ], + tidy_flags: [ + "-header-filter=hardware/google/pixel/vibrator*", + ], } cc_defaults { diff --git a/vibrator/OWNERS b/vibrator/OWNERS index 5d4a9c32..859c7e07 100644 --- a/vibrator/OWNERS +++ b/vibrator/OWNERS @@ -1,3 +1,4 @@ -chasewu@google.com +chrispaulo@google.com michaelwr@google.com +nathankulczak@google.com taikuo@google.com diff --git a/vibrator/common/Android.bp b/vibrator/common/Android.bp index 04fbc4d7..8e99827f 100644 --- a/vibrator/common/Android.bp +++ b/vibrator/common/Android.bp @@ -17,6 +17,120 @@ package { default_applicable_licenses: ["Android-Apache-2.0"], } +soong_config_module_type { + name: "haptics_feature_cc_defaults", + module_type: "cc_defaults", + config_namespace: "haptics", + variables: [ + "actuator_model", + "adaptive_haptics_feature", + ], + properties: ["cflags"], +} + +soong_config_string_variable { + name: "actuator_model", + values: [ + "luxshare_ict_081545", + "luxshare_ict_lt_xlra1906d", + ], +} + +soong_config_string_variable { + name: "adaptive_haptics_feature", + values: [ + "adaptive_haptics_v1", + ], +} + +haptics_feature_cc_defaults { + name: "haptics_feature_defaults", + soong_config_variables: { + actuator_model: { + luxshare_ict_081545: { + cflags: [ + "-DLUXSHARE_ICT_081545", + ], + }, + luxshare_ict_lt_xlra1906d: { + cflags: [ + "-DLUXSHARE_ICT_LT_XLRA1906D", + ], + }, + }, + adaptive_haptics_feature: { + adaptive_haptics_v1: { + cflags: [ + "-DADAPTIVE_HAPTICS_V1", + ], + }, + conditions_default: { + cflags: [ + "-DDISABLE_ADAPTIVE_HAPTICS_FEATURE", + ], + }, + } + }, +} + +cc_library { + name: "libvibecapo_proto", + vendor_available: true, + owner: "google", + defaults: [ + "VibratorHalCs40l26BinaryDefaults", + ], + srcs: [ + "proto/capo.proto", + ], + export_include_dirs: [ + "proto", + ], + proto: { + type: "lite", + export_proto_headers: true, + }, +} + +cc_library { + name: "VibratorCapo", + defaults: [ + "PixelVibratorBinaryDefaults", + "haptics_feature_defaults", + ], + srcs: [ + "CapoDetector.cpp", + ], + shared_libs: [ + "libcutils", + "libprotobuf-cpp-lite", + ], + static_libs: [ + "chre_client", + "libvibecapo_proto", + ], + export_include_dirs: [ + "proto", + ".", + ], + export_static_lib_headers: [ + "libvibecapo_proto", + ], + vendor_available: true, +} + +cc_defaults { + name: "VibratorCapoDefaults", + static_libs: [ + "chre_client", + "libvibecapo_proto", + "VibratorCapo", + ], + shared_libs: [ + "libprotobuf-cpp-lite", + ], +} + cc_library { name: "PixelVibratorCommon", srcs: [ @@ -30,8 +144,31 @@ cc_library { ], cflags: [ "-DATRACE_TAG=(ATRACE_TAG_VIBRATOR | ATRACE_TAG_HAL)", - "-DLOG_TAG=\"android.hardware.vibrator@1.x-common\"", + "-DLOG_TAG=\"VibratorCommon\"", ], export_include_dirs: ["."], vendor_available: true, } + +cc_library { + name: "PixelVibratorStats", + vendor: true, + srcs: ["StatsBase.cpp"], + cflags: [ + "-Werror", + "-Wall", + "-Wextra", + "-DATRACE_TAG=(ATRACE_TAG_VIBRATOR | ATRACE_TAG_HAL)", + "-DLOG_TAG=\"VibratorStats\"", + ], + shared_libs: [ + "android.frameworks.stats-V2-ndk", + "libbase", + "libcutils", + "libbinder_ndk", + "liblog", + "libprotobuf-cpp-lite", + "libutils", + "pixelatoms-cpp", + ], +} diff --git a/vibrator/common/CapoDetector.cpp b/vibrator/common/CapoDetector.cpp new file mode 100644 index 00000000..a8f3ff2b --- /dev/null +++ b/vibrator/common/CapoDetector.cpp @@ -0,0 +1,233 @@ +/* + * Copyright (C) 2023 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. + */ + +#include "CapoDetector.h" + +#include <google/protobuf/io/coded_stream.h> +#include <google/protobuf/io/zero_copy_stream_impl.h> +#include <google/protobuf/message.h> +#include <log/log.h> + +#ifdef LOG_TAG +#undef LOG_TAG +#define LOG_TAG "CapoDetector" +#endif + +namespace android { +namespace chre { + +/** + * Called when initializing connection with CHRE socket. + */ +sp<CapoDetector> CapoDetector::start() { + sp<CapoDetector> listener = new CapoDetector(); + if (!listener->connectInBackground(kChreSocketName, listener)) { + ALOGE("Couldn't connect to CHRE socket"); + return nullptr; + } + ALOGI("%s connect to CHRE socket.", __func__); + + return listener; +} + +/** + * Called when the socket is successfully (re-)connected. + * Reset the position and try to send NanoappList request. + */ +void CapoDetector::onConnected() { + flatbuffers::FlatBufferBuilder builder; + + // Reset the last position type. + last_position_type_ = capo::PositionType::UNKNOWN; + + HostProtocolHost::encodeNanoappListRequest(builder); + if (!sendMessage(builder.GetBufferPointer(), builder.GetSize())) { + ALOGE("Failed to send NanoappList request"); + // We don't return nullptr here so that we don't change the behavior + } +} + +/** + * Called when we have failed to (re-)connect the socket after many attempts + * and are giving up. + */ +void CapoDetector::onConnectionAborted() { + ALOGE("%s, Capo Aborting Connection!", __func__); +} + +/** + * Invoked when the socket is disconnected, and this connection loss was not + * the result of an explicit call to disconnect(). + * Reset the position while disconnecting. + */ + +void CapoDetector::onDisconnected() { + last_position_type_ = capo::PositionType::UNKNOWN; +} + +/** + * Decode unix socket msgs to CHRE messages, and call the appropriate + * callback depending on the CHRE message. + */ +void CapoDetector::onMessageReceived(const void *data, size_t length) { + if (!HostProtocolHost::decodeMessageFromChre(data, length, *this)) { + ALOGE("Failed to decode message"); + } +} + +/** + * Listen for messages from capo nanoapp and handle the message. + */ +void CapoDetector::handleNanoappMessage(const fbs::NanoappMessageT &message) { + ALOGI("%s, Id %" PRIu64 ", type %d, size %d", __func__, message.app_id, message.message_type, + static_cast<int>(message.message.size())); + // Exclude the message with unmatched nanoapp id. + if (message.app_id != kCapoNanoappId) + return; + + // Handle the message with message_type. + switch (message.message_type) { + case capo::MessageType::ACK_NOTIFICATION: { + capo::AckNotification gd; + gd.set_notification_type(static_cast<capo::NotificationType>(message.message[1])); + ALOGD("%s, get notification event from capo nanoapp, type %d", __func__, + gd.notification_type()); + break; + } + case capo::MessageType::POSITION_DETECTED: { + uint8_t position; + uint32_t time; + { + std::lock_guard<std::mutex> lock(mCapoMutex); + capo::PositionDetected gd; + time = getCurrentTimeInMs(); + gd.set_position_type(static_cast<capo::PositionType>(message.message[1])); + ALOGD("CapoDetector: [%u] get position event from capo nanoapp, from %d to %d", + time, last_position_type_, gd.position_type()); + + // Record the last moment we were in FACE_UP state + if (last_position_type_ == capo::PositionType::ON_TABLE_FACE_UP || + gd.position_type() == capo::PositionType::ON_TABLE_FACE_UP) { + mLastFaceUpEvent = time; + } + last_position_type_ = gd.position_type(); + position = last_position_type_; + } + // Callback to function while getting carried position event. + if (callback_func_ != nullptr) { + ALOGD("%s, sent position type %d to callback function", __func__, + last_position_type_); + callback_func_(last_position_type_); + } + break; + } + default: + ALOGE("%s, get invalid message, type: %" PRIu32 ", from capo nanoapp.", __func__, + message.message_type); + break; + } +} + +/** + * Handle the response of a NanoappList request. + * Ensure that capo nanoapp is running. + */ +void CapoDetector::handleNanoappListResponse(const fbs::NanoappListResponseT &response) { + for (const std::unique_ptr<fbs::NanoappListEntryT> &nanoapp : response.nanoapps) { + if (nanoapp->app_id == kCapoNanoappId) { + if (nanoapp->enabled) + enable(); + else + ALOGE("Capo nanoapp not enabled"); + return; + } + } + ALOGE("Capo nanoapp not found"); +} + +/** + * Send enabling message to the nanoapp. + */ +void CapoDetector::enable() { + // Create CHRE message with serialized message + flatbuffers::FlatBufferBuilder builder, config_builder, force_builder; + + auto config_data = std::make_unique<capo::ConfigureDetector_ConfigData>(); + auto msg = std::make_unique<capo::ConfigureDetector>(); + + config_data->set_still_time_threshold_nanosecond( + mCapoDetectorMDParameters.still_time_threshold_ns); + config_data->set_window_width_nanosecond(mCapoDetectorMDParameters.window_width_ns); + config_data->set_motion_confidence_threshold( + mCapoDetectorMDParameters.motion_confidence_threshold); + config_data->set_still_confidence_threshold( + mCapoDetectorMDParameters.still_confidence_threshold); + config_data->set_var_threshold(mCapoDetectorMDParameters.var_threshold); + config_data->set_var_threshold_delta(mCapoDetectorMDParameters.var_threshold_delta); + + msg->set_allocated_config_data(config_data.release()); + + auto pb_size = msg->ByteSizeLong(); + auto pb_data = std::make_unique<uint8_t[]>(pb_size); + + if (!msg->SerializeToArray(pb_data.get(), pb_size)) { + ALOGE("Failed to serialize message."); + } + + ALOGI("Configuring CapoDetector"); + // Configure the detector from host-side + ::android::chre::HostProtocolHost::encodeNanoappMessage( + config_builder, getNanoppAppId(), capo::MessageType::CONFIGURE_DETECTOR, + getHostEndPoint(), pb_data.get(), pb_size); + ALOGI("Sending capo config message to Nanoapp, %" PRIu32 " bytes", config_builder.GetSize()); + if (!sendMessage(config_builder.GetBufferPointer(), config_builder.GetSize())) { + ALOGE("Failed to send config event for capo nanoapp"); + } + + ALOGI("Enabling CapoDetector"); + ::android::chre::HostProtocolHost::encodeNanoappMessage( + builder, getNanoppAppId(), capo::MessageType::ENABLE_DETECTOR, getHostEndPoint(), + /*messageData*/ nullptr, /*messageDataLenbuffer*/ 0); + ALOGI("Sending enable message to Nanoapp, %" PRIu32 " bytes", builder.GetSize()); + if (!sendMessage(builder.GetBufferPointer(), builder.GetSize())) { + ALOGE("Failed to send enable event for capo nanoapp"); + } + + ALOGI("Forcing CapoDetector to update state"); + // Force an updated state upon connection + ::android::chre::HostProtocolHost::encodeNanoappMessage( + force_builder, getNanoppAppId(), capo::MessageType::FORCE_UPDATE, getHostEndPoint(), + /*messageData*/ nullptr, /*messageDataLenbuffer*/ 0); + ALOGI("Sending force-update message to Nanoapp, %" PRIu32 " bytes", force_builder.GetSize()); + if (!sendMessage(force_builder.GetBufferPointer(), force_builder.GetSize())) { + ALOGE("Failed to send force-update event for capo nanoapp"); + } +} + +/** + * Method for gathering the position and time tuple simultaneously to avoid any + * concurrency issues. + */ +void CapoDetector::getCarriedPositionInfo(uint8_t *position, uint32_t *time) { + std::lock_guard<std::mutex> lock(mCapoMutex); + if (position) + *position = last_position_type_; + if (time) + *time = mLastFaceUpEvent; +} + +} // namespace chre +} // namespace android diff --git a/vibrator/common/CapoDetector.h b/vibrator/common/CapoDetector.h new file mode 100644 index 00000000..f8cdc6fa --- /dev/null +++ b/vibrator/common/CapoDetector.h @@ -0,0 +1,118 @@ +/* + * Copyright (C) 2023 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. + */ + +#include <chre_host/host_protocol_host.h> +#include <chre_host/socket_client.h> + +#include <chrono> + +#include "proto/capo.pb.h" + +using android::sp; +using android::chre::HostProtocolHost; +using android::chre::IChreMessageHandlers; +using android::chre::SocketClient; + +// following convention of CHRE code. +namespace fbs = ::chre::fbs; + +namespace android { +namespace chre { + +#define NS_FROM_MS(x) ((x)*1000000) + +struct CapoMDParams { + uint64_t still_time_threshold_ns; + uint32_t window_width_ns; + float motion_confidence_threshold; + float still_confidence_threshold; + float var_threshold; + float var_threshold_delta; +}; + +class CapoDetector : public android::chre::SocketClient::ICallbacks, + public android::chre::IChreMessageHandlers, + public android::chre::SocketClient { + public: + // Typedef declaration for callback function. + typedef std::function<void(uint8_t)> cb_fn_t; + + // Called when initializing connection with CHRE socket. + static android::sp<CapoDetector> start(); + // Common getTime function to share + static uint32_t getCurrentTimeInMs() { + return std::chrono::duration_cast<std::chrono::milliseconds>( + std::chrono::system_clock::now().time_since_epoch()) + .count(); + } + // Called when the socket is successfully (re-)connected. + // Reset the position and try to send NanoappList request. + void onConnected() override; + // Called when we have failed to (re-)connect the socket after many attempts + // and are giving up. + void onConnectionAborted() override; + // Invoked when the socket is disconnected, and this connection loss + // was not the result of an explicit call to disconnect(). + // Reset the position while disconnecting. + void onDisconnected() override; + // Decode unix socket msgs to CHRE messages, and call the appropriate + // callback depending on the CHRE message. + void onMessageReceived(const void *data, size_t length) override; + // Listen for messages from capo nanoapp and handle the message. + void handleNanoappMessage(const ::chre::fbs::NanoappMessageT &message) override; + // Handle the response of a NanoappList request. + // Ensure that capo nanoapp is running. + void handleNanoappListResponse(const ::chre::fbs::NanoappListResponseT &response) override; + // Send enabling message to the nanoapp. + void enable(); + // Get last carried position type and time simultaneously. + void getCarriedPositionInfo(uint8_t *position, uint32_t *time); + // Get last carried position type. + uint8_t getCarriedPosition() { return last_position_type_; } + // Get the host endpoint. + uint16_t getHostEndPoint() { return kHostEndpoint; } + // Get the capo nanoapp ID. + uint64_t getNanoppAppId() { return kCapoNanoappId; } + // Set up callback_func_ if needed. + void setCallback(cb_fn_t cb) { callback_func_ = cb; } + + private: + // Nanoapp ID of capo, ref: go/nanoapp-id-tracker. + static constexpr uint64_t kCapoNanoappId = 0x476f6f676c001020ULL; + // String of socket name for connecting chre. + static constexpr char kChreSocketName[] = "chre"; + // The host endpoint we use when sending message. + // Set with 0x9020 based on 0x8000 AND capo_app_id(1020). + // Ref: go/host-endpoint-id-tracker. + static constexpr uint16_t kHostEndpoint = 0x9020; + // Using for hal layer callback function. + cb_fn_t callback_func_ = nullptr; + // Last carried position received from the nano app + capo::PositionType last_position_type_ = capo::PositionType::UNKNOWN; + // Last face up event + uint32_t mLastFaceUpEvent = 0; + // Mutex for time + position tuple + std::mutex mCapoMutex; + // Motion detector parameters for host-driven capo config + const struct CapoMDParams mCapoDetectorMDParameters { + .still_time_threshold_ns = NS_FROM_MS(500), .window_width_ns = NS_FROM_MS(100), + .motion_confidence_threshold = 0.98f, .still_confidence_threshold = 0.99f, + .var_threshold = 0.0125f, .var_threshold_delta = 0.0125f, + }; +}; + +} // namespace chre +} // namespace android diff --git a/vibrator/common/HardwareBase.cpp b/vibrator/common/HardwareBase.cpp index 8e07e99e..f162429b 100644 --- a/vibrator/common/HardwareBase.cpp +++ b/vibrator/common/HardwareBase.cpp @@ -31,8 +31,8 @@ namespace vibrator { HwApiBase::HwApiBase() { mPathPrefix = std::getenv("HWAPI_PATH_PREFIX") ?: ""; - if (mPathPrefix.empty()) { - ALOGE("Failed get HWAPI path prefix!"); + if (mPathPrefix.empty() && (std::getenv("INPUT_EVENT_NAME") == NULL)) { + ALOGE("Failed to get HWAPI path prefix!"); } } diff --git a/vibrator/common/HardwareBase.h b/vibrator/common/HardwareBase.h index 5b070402..36c3fcad 100644 --- a/vibrator/common/HardwareBase.h +++ b/vibrator/common/HardwareBase.h @@ -15,16 +15,18 @@ */ #pragma once -#include <list> -#include <map> -#include <sstream> -#include <string> - +#include <android-base/stringprintf.h> #include <android-base/unique_fd.h> #include <log/log.h> #include <sys/epoll.h> #include <utils/Trace.h> +#include <chrono> +#include <list> +#include <map> +#include <sstream> +#include <string> + #include "utils.h" namespace aidl { @@ -32,6 +34,7 @@ namespace android { namespace hardware { namespace vibrator { +using ::android::base::StringPrintf; using ::android::base::unique_fd; class HwApiBase { @@ -47,23 +50,31 @@ class HwApiBase { class Record : public RecordInterface { public: Record(const char *func, const T &value, const std::ios *stream) - : mFunc(func), mValue(value), mStream(stream) {} + : mFunc(func), + mValue(value), + mStream(stream), + mTp(std::chrono::system_clock::system_clock::now()) {} std::string toString(const NamesMap &names) override; private: const char *mFunc; const T mValue; const std::ios *mStream; + const std::chrono::system_clock::time_point mTp; }; using Records = std::list<std::unique_ptr<RecordInterface>>; - static constexpr uint32_t RECORDS_SIZE = 32; + static constexpr uint32_t RECORDS_SIZE = 2048; public: HwApiBase(); void debug(int fd); protected: + void updatePathPrefix(const std::string &prefix) { + ALOGI("Update HWAPI path prefix to %s", prefix.c_str()); + mPathPrefix = prefix; + } void saveName(const std::string &name, const std::ios *stream); template <typename T> void open(const std::string &name, T *stream); @@ -125,7 +136,9 @@ bool HwApiBase::set(const T &value, std::ostream *stream) { template <typename T> bool HwApiBase::poll(const T &value, std::istream *stream, const int32_t timeoutMs) { - ATRACE_NAME("HwApi::poll"); + ATRACE_NAME(StringPrintf("HwApi::poll %s==%s", mNames[stream].c_str(), + std::to_string(value).c_str()) + .c_str()); auto path = mPathPrefix + mNames[stream]; unique_fd fileFd{::open(path.c_str(), O_RDONLY)}; unique_fd epollFd{epoll_create(1)}; @@ -169,9 +182,14 @@ template <typename T> std::string HwApiBase::Record<T>::toString(const NamesMap &names) { using utils::operator<<; std::stringstream ret; - - ret << mFunc << " '" << names.at(mStream) << "' = '" << mValue << "'"; - + auto lTp = std::chrono::system_clock::to_time_t(mTp); + struct tm buf; + auto lTime = localtime_r(&lTp, &buf); + + ret << std::put_time(lTime, "%Y-%m-%d %H:%M:%S.") << std::setfill('0') << std::setw(3) + << (std::chrono::duration_cast<std::chrono::milliseconds>(mTp.time_since_epoch()) % 1000) + .count() + << " " << mFunc << " '" << names.at(mStream) << "' = '" << mValue << "'"; return ret.str(); } diff --git a/vibrator/common/StatsBase.cpp b/vibrator/common/StatsBase.cpp new file mode 100644 index 00000000..68b8a2dc --- /dev/null +++ b/vibrator/common/StatsBase.cpp @@ -0,0 +1,289 @@ +/* + * 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. + */ + +#include "StatsBase.h" + +#include <aidl/android/frameworks/stats/IStats.h> +#include <android/binder_manager.h> +#include <hardware/google/pixel/pixelstats/pixelatoms.pb.h> +#include <log/log.h> +#include <utils/Trace.h> + +#include <chrono> +#include <sstream> + +using ::aidl::android::frameworks::stats::IStats; +using ::aidl::android::frameworks::stats::VendorAtom; +using ::aidl::android::frameworks::stats::VendorAtomValue; + +namespace PixelAtoms = ::android::hardware::google::pixel::PixelAtoms; + +#ifndef ARRAY_SIZE +#define ARRAY_SIZE(x) (sizeof((x)) / sizeof((x)[0])) +#endif + +#ifdef TRACE_STATS +static const char *kAtomLookup[] = {"HAPTICS_PLAYCOUNTS", "HAPTICS_LATENCIES", "HAPTICS_ERRORS", + "INVALID"}; + +const char *atomToString(uint32_t atomId) { + switch (atomId) { + case PixelAtoms::Atom::kVibratorPlaycountReported: + return kAtomLookup[0]; + break; + case PixelAtoms::Atom::kVibratorLatencyReported: + return kAtomLookup[1]; + break; + case PixelAtoms::Atom::kVibratorErrorsReported: + return kAtomLookup[2]; + break; + default: + return kAtomLookup[ARRAY_SIZE(kAtomLookup) - 1]; + break; + } +} + +#define STATS_TRACE(...) \ + ATRACE_NAME(__func__); \ + ALOGD(__VA_ARGS__) +#else +#define STATS_TRACE(...) ATRACE_NAME(__func__) +#define atomToString(x) +#endif + +namespace aidl { +namespace android { +namespace hardware { +namespace vibrator { + +#ifdef FAST_LOG +static constexpr auto UPLOAD_INTERVAL = std::chrono::minutes(1); +#else +static constexpr auto UPLOAD_INTERVAL = std::chrono::hours(24); +#endif + +static void reportVendorAtom(const std::shared_ptr<IStats> &statsClient, const VendorAtom &atom) { + STATS_TRACE(" reportVendorAtom(statsClient, atom: %s)", atomToString(atom.atomId)); + const ndk::ScopedAStatus status = statsClient->reportVendorAtom(atom); + if (status.isOk()) { + ALOGI("Vendor atom [id = %d] reported.", atom.atomId); + } else { + ALOGE("Failed to report atom [id = %d].", atom.atomId); + } +} + +static std::string dumpData(const std::vector<int32_t> &data) { + std::stringstream stream; + for (auto datum : data) { + stream << " " << datum; + } + return stream.str(); +} + +StatsBase::StatsBase(const std::string &instance) + : mReporterThread([this]() { runReporterThread(); }), + kStatsInstanceName(std::string() + IStats::descriptor + "/" + instance) {} + +StatsBase::~StatsBase() {} + +void StatsBase::debug(int fd) { + STATS_TRACE("debug(fd: %d)", fd); + + dprintf(fd, "Stats:\n"); + { + std::scoped_lock<std::mutex> lock(mDataAccess); + dprintf(fd, " Waveform Counts:%s\n", dumpData(mWaveformCounts).c_str()); + dprintf(fd, " Duration Counts:%s\n", dumpData(mDurationCounts).c_str()); + dprintf(fd, " Min Latencies:%s\n", dumpData(mMinLatencies).c_str()); + dprintf(fd, " Max Latencies:%s\n", dumpData(mMaxLatencies).c_str()); + dprintf(fd, " Latency Totals:%s\n", dumpData(mLatencyTotals).c_str()); + dprintf(fd, " Latency Counts:%s\n", dumpData(mLatencyCounts).c_str()); + dprintf(fd, " Error Counts: %s\n", dumpData(mErrorCounts).c_str()); + } +} + +void StatsBase::reportVendorAtomAsync(const VendorAtom &atom) { + STATS_TRACE("reportVendorAtomAsync(atom: %s)", atomToString(atom.atomId)); + std::scoped_lock<std::mutex> lock(mAtomQueueAccess); + mAtomQueue.push_back(atom); + mAtomQueueUpdated.notify_all(); +} + +void StatsBase::uploadDiagnostics() { + STATS_TRACE("uploadDiagnostics()"); + uploadPlaycountAtoms(); + uploadLatencyAtoms(); + uploadErrorAtoms(); +} + +void StatsBase::waitForStatsService() const { + STATS_TRACE("waitForStatsService()"); + if (!AServiceManager_isDeclared(kStatsInstanceName.c_str())) { + ALOGE("IStats service '%s' is not registered.", kStatsInstanceName.c_str()); + return; + } + + ALOGI("Waiting for IStats service '%s' to come up.", kStatsInstanceName.c_str()); + const std::shared_ptr<IStats> statsClient = IStats::fromBinder( + ndk::SpAIBinder(AServiceManager_waitForService(kStatsInstanceName.c_str()))); + if (!statsClient) { + ALOGE("Failed to get IStats service '%s'.", kStatsInstanceName.c_str()); + return; + } + ALOGI("IStats service online."); +} + +void StatsBase::runReporterThread() { + STATS_TRACE("runReporterThread()"); + using clock = std::chrono::steady_clock; + auto nextUpload = clock::now() + UPLOAD_INTERVAL; + auto status = std::cv_status::no_timeout; + + waitForStatsService(); + + while (!mTerminateReporterThread) { + drainAtomQueue(); + { + std::unique_lock<std::mutex> lock(mAtomQueueAccess); + if (!mAtomQueue.empty()) + continue; + status = mAtomQueueUpdated.wait_until(lock, nextUpload); + } + + if (status == std::cv_status::timeout) { + nextUpload = clock::now() + UPLOAD_INTERVAL; + uploadDiagnostics(); + } + } +} + +void StatsBase::drainAtomQueue() { + STATS_TRACE("drainAtomQueue()"); + std::vector<VendorAtom> tempQueue; + { + std::unique_lock<std::mutex> lock(mAtomQueueAccess); + std::swap(mAtomQueue, tempQueue); + } + + std::shared_ptr<IStats> statsClient = IStats::fromBinder( + ndk::SpAIBinder(AServiceManager_waitForService(kStatsInstanceName.c_str()))); + if (!statsClient) { + ALOGE("Failed to get IStats service. Atoms are dropped."); + return; + } + + for (const VendorAtom &atom : tempQueue) { + reportVendorAtom(statsClient, atom); + } +} + +void StatsBase::uploadPlaycountAtoms() { + STATS_TRACE("uploadPlaycountAtoms()"); + VendorAtom playcountAtom = vibratorPlaycountAtom(); + reportVendorAtomAsync(playcountAtom); + clearData(&mWaveformCounts); + clearData(&mDurationCounts); +} + +void StatsBase::uploadLatencyAtoms() { + STATS_TRACE("uploadLatencyAtoms()"); + VendorAtom latencyAtom = vibratorLatencyAtom(); + reportVendorAtomAsync(latencyAtom); + clearData(&mMinLatencies); + clearData(&mMaxLatencies); + clearData(&mLatencyTotals); + clearData(&mLatencyCounts); +} + +void StatsBase::uploadErrorAtoms() { + STATS_TRACE("uploadErrorAtoms()"); + VendorAtom errorAtom = vibratorErrorAtom(); + reportVendorAtomAsync(errorAtom); + clearData(&mErrorCounts); +} + +void StatsBase::clearData(std::vector<int32_t> *data) { + STATS_TRACE("clearData(data)"); + if (data) { + std::scoped_lock<std::mutex> lock(mDataAccess); + std::fill((*data).begin(), (*data).end(), 0); + } +} + +VendorAtom StatsBase::vibratorPlaycountAtom() { + STATS_TRACE("vibratorPlaycountAtom()"); + std::vector<VendorAtomValue> values(2); + + { + std::scoped_lock<std::mutex> lock(mDataAccess); + values[0].set<VendorAtomValue::repeatedIntValue>(mWaveformCounts); + values[1].set<VendorAtomValue::repeatedIntValue>(mDurationCounts); + } + + return VendorAtom{ + .reverseDomainName = "", + .atomId = PixelAtoms::Atom::kVibratorPlaycountReported, + .values = std::move(values), + }; +} + +VendorAtom StatsBase::vibratorLatencyAtom() { + STATS_TRACE("vibratorLatencyAtom()"); + std::vector<VendorAtomValue> values(3); + std::vector<int32_t> avgLatencies; + + { + std::scoped_lock<std::mutex> lock(mDataAccess); + for (uint32_t i = 0; i < mLatencyCounts.size(); i++) { + int32_t avg = 0; + if (mLatencyCounts[0] > 0) { + avg = mLatencyTotals[i] / mLatencyCounts[i]; + } + avgLatencies.push_back(avg); + } + + values[0].set<VendorAtomValue::repeatedIntValue>(mMinLatencies); + values[1].set<VendorAtomValue::repeatedIntValue>(mMaxLatencies); + } + values[2].set<VendorAtomValue::repeatedIntValue>(avgLatencies); + + return VendorAtom{ + .reverseDomainName = "", + .atomId = PixelAtoms::Atom::kVibratorLatencyReported, + .values = std::move(values), + }; +} + +VendorAtom StatsBase::vibratorErrorAtom() { + STATS_TRACE("vibratorErrorAtom()"); + std::vector<VendorAtomValue> values(1); + + { + std::scoped_lock<std::mutex> lock(mDataAccess); + values[0].set<VendorAtomValue::repeatedIntValue>(mErrorCounts); + } + + return VendorAtom{ + .reverseDomainName = "", + .atomId = PixelAtoms::Atom::kVibratorErrorsReported, + .values = std::move(values), + }; +} + +} // namespace vibrator +} // namespace hardware +} // namespace android +} // namespace aidl diff --git a/vibrator/common/StatsBase.h b/vibrator/common/StatsBase.h new file mode 100644 index 00000000..2e16220a --- /dev/null +++ b/vibrator/common/StatsBase.h @@ -0,0 +1,93 @@ +/* + * 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. + */ +#pragma once + +#include <utils/SystemClock.h> + +#include <cinttypes> +#include <mutex> +#include <thread> +#include <vector> + +/* Forward declaration to speed-up build and avoid build errors. Clients of this + * library force to use C++11 std, when AIDL auto-generated code uses features + * from more recent C++ version. */ +namespace aidl { +namespace android { +namespace frameworks { +namespace stats { + +class VendorAtom; + +} // namespace stats +} // namespace frameworks +} // namespace android +} // namespace aidl + +namespace aidl { +namespace android { +namespace hardware { +namespace vibrator { + +class StatsBase { + public: + using VendorAtom = ::aidl::android::frameworks::stats::VendorAtom; + + StatsBase(const std::string &instance); + ~StatsBase(); + + void debug(int fd); + + protected: + std::vector<int32_t> mWaveformCounts; + std::vector<int32_t> mDurationCounts; + std::vector<int32_t> mMinLatencies; + std::vector<int32_t> mMaxLatencies; + std::vector<int32_t> mLatencyTotals; + std::vector<int32_t> mLatencyCounts; + std::vector<int32_t> mErrorCounts; + std::mutex mDataAccess; + + private: + void runReporterThread(); + void reportVendorAtomAsync(const VendorAtom &atom); + void uploadDiagnostics(); + void waitForStatsService() const; + void drainAtomQueue(); + + void uploadPlaycountAtoms(); + void uploadLatencyAtoms(); + void uploadErrorAtoms(); + + void clearData(std::vector<int32_t> *data); + + VendorAtom vibratorPlaycountAtom(); + VendorAtom vibratorLatencyAtom(); + VendorAtom vibratorErrorAtom(); + + std::thread mReporterThread; + std::vector<VendorAtom> mAtomQueue; + std::mutex mAtomQueueAccess; + std::condition_variable mAtomQueueUpdated; + bool mTerminateReporterThread = false; + + const std::string kStatsInstanceName; +}; + +} // namespace vibrator +} // namespace hardware +} // namespace android +} // namespace aidl diff --git a/vibrator/common/proto/capo.proto b/vibrator/common/proto/capo.proto new file mode 100644 index 00000000..2b1939cc --- /dev/null +++ b/vibrator/common/proto/capo.proto @@ -0,0 +1,164 @@ +/* + * Copyright (C) 2023 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. + */ + +syntax = "proto3"; + +package capo; + +// The message types used in capo nanoapp. Some of them are H2C +// (Host-To-CHRE) and others are C2H (CHRE-To-Host). One message type must be +// either H2C or C2H. Each message type can choose to have payload or not. +enum MessageType { + // Explicitly prevents 0 from being used as a valid message type. + // Doing so protects from obscure bugs caused by default-initialized values. + INVALID = 0; + + // Detector configuration related message start from 100. + // Signal for host to acknowledge the notification. + // It contains AckNotification payload. + ACK_NOTIFICATION = 100; + + // Signal to enable the carried position detector for device. No payload. + ENABLE_DETECTOR = 101; + + // Signal to disable the carried position detector for device. No payload. + DISABLE_DETECTOR = 102; + + // Signal to request most recent carried position detector state. No payload. + REQUEST_UPDATE = 103; + + // Signal to force carried position detector to refresh state. No payload. + FORCE_UPDATE = 104; + + // Configure the detector with desired parameters. ConfigureDetector payload. + CONFIGURE_DETECTOR = 105; + + // Position Detection related message start from 200. + // Signal while carried position of device detected. + // It contains PositionDetected payload. + POSITION_DETECTED = 200; +} + +// Notification Type. +enum NotificationType { + // Explicitly prevents 0 from being used as a valid notification type. + // Doing so protects from obscure bugs caused by default-initialized values. + INVALID_NOTIFICATION = 0; + + // Notification of enabling the carried position detector for device. + ENABLE_NOTIFICATION = 1; + + // Notification of disabling the carried position detector for device. + DISABLE_NOTIFICATION = 2; + + // Notification of request update from the carried position detector. + REQUEST_UPDATE_NOTIFICATION = 3; + + // Notification of force update from the carried position detector. + FORCE_UPDATE_NOTIFICATION = 4; + + // Notification of configure message. + CONFIGURE_NOTIFICATION = 5; +} + +// This message type used for host to acknowledge the notification. +message AckNotification { + // Sent a notification type for host to acknowledge. + NotificationType notification_type = 1; +} + +// Position type. +enum PositionType { + // Explicitly prevents 0 from being used as a valid carried position type. + // Doing so protects from obscure bugs caused by default-initialized values. + UNKNOWN = 0; + + // Carried position while device is in motion. + IN_MOTION = 1; + + // Carried position while device is on table and faces up. + ON_TABLE_FACE_UP = 2; + + // Carried position while device is on table and faces down. + ON_TABLE_FACE_DOWN = 3; + + // Carried position while device is stationary in unknown orientation. + STATIONARY_UNKNOWN = 4; +} + +// This message type used to notify host a position was a detected. +message PositionDetected { + // Sent a position type that is defined in PositionTypes. + PositionType position_type = 1; +} + +// Predefined configurations for detector. +enum ConfigPresetType { + // Explicitly prevents 0 from being used as a valid type. + // Doing so protects from obscure bugs caused by default-initialized values. + CONFIG_PRESET_UNSPECIFIED = 0; + + // Default preset. + CONFIG_PRESET_DEFAULT = 1; + + // Preset for sticky-stationary behavior. + CONFIG_PRESET_STICKY_STATIONARY = 2; +} + +message ConfigureDetector { + // Ref: cs/location/lbs/contexthub/nanoapps/motiondetector/motion_detector.h + message ConfigData { + // These algo parameters are exposed to enable tuning via server flags. + // The amount of time that the algorithm's computed stillness confidence + // must exceed still_confidence_threshold before entering the stationary + // state. Increasing this value will make the algorithm take longer to + // transition from the in motion state to the stationary state. + uint64 still_time_threshold_nanosecond = 1; + + // The amount of time in which the variance should be averaged. Increasing + // this value will effectively smooth the input data, making the algorithm + // less likely to transition between states. + uint32 window_width_nanosecond = 2; + + // The required confidence that the device is in motion before entering the + // motion state. Valid range is [0.0, 1.0], where 1.0 indicates that the + // algorithm must be 100% certain that the device is moving before entering + // the motion state. If the Instant Motion sensor is triggered, this value + // is ignored and the algorithm is immediately transitioned into the in + // motion state. + float motion_confidence_threshold = 3; + + // The required confidence that the device is stationary before entering the + // stationary state. Valid range is [0.0, 1.0], where 1.0 indicates that the + // algorithm must be 100% certain that the device is stationary before + // entering the stationary state. + float still_confidence_threshold = 4; + + // The variance threshold for the StillnessDetector algorithm. Increasing + // this value causes the algorithm to be less likely to detect motion. + float var_threshold = 5; + + // The variance threshold delta for the StillnessDetector algorithm about + // which the stationary confidence is calculated. Valid range is + // [0.0, var_threshold]. + float var_threshold_delta = 6; + } + + oneof type { + ConfigPresetType preset_type = 1; + ConfigData config_data = 2; + } +} diff --git a/vibrator/cs40l25/Android.bp b/vibrator/cs40l25/Android.bp index 13d59adb..7c4fe7e8 100644 --- a/vibrator/cs40l25/Android.bp +++ b/vibrator/cs40l25/Android.bp @@ -17,46 +17,11 @@ package { default_applicable_licenses: ["Android-Apache-2.0"], } -soong_config_module_type { - name: "haptics_feature_cc_defaults", - module_type: "cc_defaults", - config_namespace: "haptics", - variables: [ - "actuator_model", - ], - properties: ["cflags"], -} - -soong_config_string_variable { - name: "actuator_model", - values: [ - "luxshare_ict_081545", - "luxshare_ict_lt_xlra1906d", - ], -} - -haptics_feature_cc_defaults { - name: "haptics_feature_defaults", - soong_config_variables: { - actuator_model: { - luxshare_ict_081545: { - cflags: [ - "-DLUXSHARE_ICT_081545", - ], - }, - luxshare_ict_lt_xlra1906d: { - cflags: [ - "-DLUXSHARE_ICT_LT_XLRA1906D", - ], - }, - }, - }, -} - cc_defaults { name: "android.hardware.vibrator-defaults.cs40l25", cflags: [ "-DATRACE_TAG=(ATRACE_TAG_VIBRATOR | ATRACE_TAG_HAL)", + "-DLOG_TAG=\"Vibrator\"", ], shared_libs: [ "libbinder", @@ -108,9 +73,9 @@ cc_binary { init_rc: ["android.hardware.vibrator-service.cs40l25.rc"], vintf_fragments: ["android.hardware.vibrator-service.cs40l25.xml"], srcs: ["service.cpp"], - shared_libs: ["android.hardware.vibrator-impl.cs40l25"], - cflags: [ - "-DLOG_TAG=\"android.hardware.vibrator-cs40l25\"", + shared_libs: [ + "android.hardware.vibrator-impl.cs40l25", + "PixelVibratorStats", ], proprietary: true, } @@ -121,10 +86,12 @@ cc_binary { init_rc: ["android.hardware.vibrator-service.cs40l25-dual.rc"], vintf_fragments: ["android.hardware.vibrator-service.cs40l25-dual.xml"], srcs: ["service.cpp"], - shared_libs: ["android.hardware.vibrator-impl.cs40l25"], + shared_libs: [ + "android.hardware.vibrator-impl.cs40l25", + "PixelVibratorStats", + ], cflags: [ "-DVIBRATOR_NAME=\"dual\"", - "-DLOG_TAG=\"android.hardware.vibrator-cs40l25-dual\"", ], proprietary: true, } diff --git a/vibrator/cs40l25/Hardware.h b/vibrator/cs40l25/Hardware.h index 167e382b..e2222798 100644 --- a/vibrator/cs40l25/Hardware.h +++ b/vibrator/cs40l25/Hardware.h @@ -72,7 +72,9 @@ class HwApi : public Vibrator::HwApi, private HwApiBase { bool setGpioFallScale(uint32_t value) override { return set(value, &mGpioFallScale); } bool setGpioRiseIndex(uint32_t value) override { return set(value, &mGpioRiseIndex); } bool setGpioRiseScale(uint32_t value) override { return set(value, &mGpioRiseScale); } - bool pollVibeState(bool value) override { return poll(value, &mVibeState); } + bool pollVibeState(uint32_t value, int32_t timeoutMs) override { + return poll(value, &mVibeState, timeoutMs); + } bool setClabEnable(bool value) override { return set(value, &mClabEnable); } bool getAvailablePwleSegments(uint32_t *value) override { return get(value, &mAvailablePwleSegments); diff --git a/vibrator/cs40l25/Stats.h b/vibrator/cs40l25/Stats.h new file mode 100644 index 00000000..f6a7a347 --- /dev/null +++ b/vibrator/cs40l25/Stats.h @@ -0,0 +1,292 @@ +/* + * 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. + */ +#pragma once + +#include <log/log.h> +#include <utils/Trace.h> + +#include <algorithm> +#include <chrono> +#include <mutex> + +#include "StatsBase.h" +#include "Vibrator.h" + +constexpr int32_t DURATION_BUCKET_WIDTH = 50; +constexpr int32_t DURATION_50MS_BUCKET_COUNT = 20; +constexpr int32_t DURATION_BUCKET_COUNT = DURATION_50MS_BUCKET_COUNT + 1; +constexpr uint32_t MAX_TIME_MS = UINT16_MAX; + +#ifndef ARRAY_SIZE +#define ARRAY_SIZE(x) (sizeof((x)) / sizeof((x)[0])) +#endif + +#ifdef HAPTIC_TRACE +static const char *kWaveformLookup[] = {"WAVEFORM_LONG_VIBRATION_EFFECT", + "WAVEFORM_RESERVED_1", + "WAVEFORM_CLICK", + "WAVEFORM_SHORT_VIBRATION_EFFECT", + "WAVEFORM_THUD", + "WAVEFORM_SPIN", + "WAVEFORM_QUICK_RISE", + "WAVEFORM_SLOW_RISE", + "WAVEFORM_QUICK_FALL", + "WAVEFORM_LIGHT_TICK", + "WAVEFORM_LOW_TICK", + "WAVEFORM_RESERVED_MFG_1", + "WAVEFORM_RESERVED_MFG_2", + "WAVEFORM_RESERVED_MFG_3", + "WAVEFORM_COMPOSE", + "WAVEFORM_PWLE", + "INVALID"}; +static const char *kLatencyLookup[] = {"kWaveformEffectLatency", "kPrebakedEffectLatency", + "kCompositionEffectLatency", "kPwleEffectLatency", + "INVALID"}; +static const char *kErrorLookup[] = {"kInitError", + "kHwApiError", + "kHwCalError", + "kComposeFailError", + "kAlsaFailError", + "kAsyncFailError", + "kBadTimeoutError", + "kBadAmplitudeError", + "kBadEffectError", + "kBadEffectStrengthError", + "kBadPrimitiveError", + "kBadCompositeError", + "kPwleConstructionFailError", + "kUnsupportedOpError", + "INVALID"}; + +const char *waveformToString(uint16_t index) { + return kWaveformLookup[(index < ARRAY_SIZE(kWaveformLookup)) ? index + : ARRAY_SIZE(kWaveformLookup) - 1]; +} + +const char *latencyToString(uint16_t index) { + return kLatencyLookup[(index < ARRAY_SIZE(kLatencyLookup)) ? index + : ARRAY_SIZE(kLatencyLookup) - 1]; +} + +const char *errorToString(uint16_t index) { + return kErrorLookup[(index < ARRAY_SIZE(kErrorLookup)) ? index : ARRAY_SIZE(kErrorLookup) - 1]; +} + +#define STATS_TRACE(...) \ + ATRACE_NAME(__func__); \ + ALOGD(__VA_ARGS__) +#else +#define STATS_TRACE(...) ATRACE_NAME(__func__) +#define waveformToString(x) +#define latencyToString(x) +#define errorToString(x) +#endif + +namespace aidl { +namespace android { +namespace hardware { +namespace vibrator { + +enum EffectLatency : uint16_t { + kWaveformEffectLatency = 0, + kPrebakedEffectLatency, + kCompositionEffectLatency, + kPwleEffectLatency, + + kEffectLatencyCount +}; + +enum VibratorError : uint16_t { + kInitError = 0, + kHwApiError, + kHwCalError, + kComposeFailError, + kAlsaFailError, + kAsyncFailError, + kBadTimeoutError, + kBadAmplitudeError, + kBadEffectError, + kBadEffectStrengthError, + kBadPrimitiveError, + kBadCompositeError, + kPwleConstructionFailError, + kUnsupportedOpError, + + kVibratorErrorCount +}; + +class StatsApi : public Vibrator::StatsApi, private StatsBase { + private: + static constexpr uint32_t BASE_CONTINUOUS_EFFECT_OFFSET = 32768; + enum WaveformIndex : uint16_t { + /* Physical waveform */ + WAVEFORM_LONG_VIBRATION_EFFECT_INDEX = 0, + WAVEFORM_RESERVED_INDEX_1 = 1, + WAVEFORM_CLICK_INDEX = 2, + WAVEFORM_SHORT_VIBRATION_EFFECT_INDEX = 3, + WAVEFORM_THUD_INDEX = 4, + WAVEFORM_SPIN_INDEX = 5, + WAVEFORM_QUICK_RISE_INDEX = 6, + WAVEFORM_SLOW_RISE_INDEX = 7, + WAVEFORM_QUICK_FALL_INDEX = 8, + WAVEFORM_LIGHT_TICK_INDEX = 9, + WAVEFORM_LOW_TICK_INDEX = 10, + WAVEFORM_RESERVED_MFG_1, + WAVEFORM_RESERVED_MFG_2, + WAVEFORM_RESERVED_MFG_3, + WAVEFORM_MAX_PHYSICAL_INDEX, + /* OWT waveform */ + WAVEFORM_COMPOSE = WAVEFORM_MAX_PHYSICAL_INDEX, + WAVEFORM_PWLE, + /* + * Refer to <linux/input.h>, the WAVEFORM_MAX_INDEX must not exceed 96. + * #define FF_GAIN 0x60 // 96 in decimal + * #define FF_MAX_EFFECTS FF_GAIN + */ + WAVEFORM_MAX_INDEX, + }; + + public: + StatsApi() + : StatsBase(std::string(std::getenv("STATS_INSTANCE"))), + mCurrentLatencyIndex(kEffectLatencyCount) { + mWaveformCounts = std::vector<int32_t>(WAVEFORM_MAX_INDEX, 0); + mDurationCounts = std::vector<int32_t>(DURATION_BUCKET_COUNT, 0); + mMinLatencies = std::vector<int32_t>(kEffectLatencyCount, 0); + mMaxLatencies = std::vector<int32_t>(kEffectLatencyCount, 0); + mLatencyTotals = std::vector<int32_t>(kEffectLatencyCount, 0); + mLatencyCounts = std::vector<int32_t>(kEffectLatencyCount, 0); + mErrorCounts = std::vector<int32_t>(kVibratorErrorCount, 0); + } + + bool logPrimitive(uint16_t effectIndex) override { + STATS_TRACE("logPrimitive(effectIndex: %s)", waveformToString(effectIndex)); + + if (effectIndex >= WAVEFORM_MAX_PHYSICAL_INDEX || + effectIndex == WAVEFORM_LONG_VIBRATION_EFFECT_INDEX || + effectIndex == WAVEFORM_SHORT_VIBRATION_EFFECT_INDEX) { + ALOGE("Invalid waveform index for logging primitive: %d", effectIndex); + return false; + } + + { + std::scoped_lock<std::mutex> lock(mDataAccess); + mWaveformCounts[effectIndex]++; + } + + return true; + } + + bool logWaveform(uint16_t effectIndex, int32_t duration) override { + STATS_TRACE("logWaveform(effectIndex: %s, duration: %d)", waveformToString(effectIndex), + duration); + + if (effectIndex != WAVEFORM_LONG_VIBRATION_EFFECT_INDEX && + effectIndex != WAVEFORM_SHORT_VIBRATION_EFFECT_INDEX + BASE_CONTINUOUS_EFFECT_OFFSET) { + ALOGE("Invalid waveform index for logging waveform: %d", effectIndex); + return false; + } else if (effectIndex == + WAVEFORM_SHORT_VIBRATION_EFFECT_INDEX + BASE_CONTINUOUS_EFFECT_OFFSET) { + effectIndex = WAVEFORM_SHORT_VIBRATION_EFFECT_INDEX; + } + + if (duration > MAX_TIME_MS || duration < 0) { + ALOGE("Invalid waveform duration for logging waveform: %d", duration); + return false; + } + + { + std::scoped_lock<std::mutex> lock(mDataAccess); + mWaveformCounts[effectIndex]++; + if (duration < DURATION_BUCKET_WIDTH * DURATION_50MS_BUCKET_COUNT) { + mDurationCounts[duration / DURATION_BUCKET_WIDTH]++; + } else { + mDurationCounts[DURATION_50MS_BUCKET_COUNT]++; + } + } + + return true; + } + + bool logError(uint16_t errorIndex) override { + STATS_TRACE("logError(errorIndex: %s)", errorToString(errorIndex)); + + if (errorIndex >= kVibratorErrorCount) { + ALOGE("Invalid index for logging error: %d", errorIndex); + return false; + } + + { + std::scoped_lock<std::mutex> lock(mDataAccess); + mErrorCounts[errorIndex]++; + } + + return true; + } + + bool logLatencyStart(uint16_t latencyIndex) override { + STATS_TRACE("logLatencyStart(latencyIndex: %s)", latencyToString(latencyIndex)); + + if (latencyIndex >= kEffectLatencyCount) { + ALOGE("Invalid index for measuring latency: %d", latencyIndex); + return false; + } + + mCurrentLatencyStart = std::chrono::steady_clock::now(); + mCurrentLatencyIndex = latencyIndex; + + return true; + } + + bool logLatencyEnd() override { + STATS_TRACE("logLatencyEnd()"); + + if (mCurrentLatencyIndex >= kEffectLatencyCount) { + return false; + } + + int32_t latency = (std::chrono::duration_cast<std::chrono::milliseconds>( + std::chrono::steady_clock::now() - mCurrentLatencyStart)) + .count(); + + { + std::scoped_lock<std::mutex> lock(mDataAccess); + if (latency < mMinLatencies[mCurrentLatencyIndex] || + mMinLatencies[mCurrentLatencyIndex] == 0) { + mMinLatencies[mCurrentLatencyIndex] = latency; + } + if (latency > mMaxLatencies[mCurrentLatencyIndex]) { + mMaxLatencies[mCurrentLatencyIndex] = latency; + } + mLatencyTotals[mCurrentLatencyIndex] += latency; + mLatencyCounts[mCurrentLatencyIndex]++; + } + + mCurrentLatencyIndex = kEffectLatencyCount; + return true; + } + + void debug(int fd) override { StatsBase::debug(fd); } + + private: + uint16_t mCurrentLatencyIndex; + std::chrono::time_point<std::chrono::steady_clock> mCurrentLatencyStart; +}; + +} // namespace vibrator +} // namespace hardware +} // namespace android +} // namespace aidl diff --git a/vibrator/cs40l25/Vibrator.cpp b/vibrator/cs40l25/Vibrator.cpp index 669258f2..1363dbe1 100644 --- a/vibrator/cs40l25/Vibrator.cpp +++ b/vibrator/cs40l25/Vibrator.cpp @@ -30,6 +30,8 @@ #include <map> #include <sstream> +#include "Stats.h" + #ifndef ARRAY_SIZE #define ARRAY_SIZE(x) (sizeof((x)) / sizeof((x)[0])) #endif @@ -42,6 +44,12 @@ namespace android { namespace hardware { namespace vibrator { +#ifdef HAPTIC_TRACE +#define HAPTICS_TRACE(...) ALOGD(__VA_ARGS__) +#else +#define HAPTICS_TRACE(...) +#endif + static constexpr uint32_t BASE_CONTINUOUS_EFFECT_OFFSET = 32768; static constexpr uint32_t WAVEFORM_EFFECT_0_20_LEVEL = 0; @@ -65,7 +73,6 @@ static constexpr uint32_t WAVEFORM_LOW_TICK_INDEX = 10; static constexpr uint32_t WAVEFORM_UNSAVED_TRIGGER_QUEUE_INDEX = 65529; static constexpr uint32_t WAVEFORM_TRIGGER_QUEUE_INDEX = 65534; - static constexpr uint32_t VOLTAGE_GLOBAL_SCALE_LEVEL = 5; static constexpr uint8_t VOLTAGE_SCALE_MAX = 100; @@ -77,6 +84,7 @@ static constexpr float AMP_ATTENUATE_STEP_SIZE = 0.125f; static constexpr float EFFECT_FREQUENCY_KHZ = 48.0f; static constexpr auto ASYNC_COMPLETION_TIMEOUT = std::chrono::milliseconds(100); +static constexpr auto POLLING_TIMEOUT = 20; static constexpr int32_t COMPOSE_DELAY_MAX_MS = 10000; static constexpr int32_t COMPOSE_SIZE_MAX = 127; @@ -106,13 +114,13 @@ static constexpr float PWLE_LEVEL_MIN = 0.0f; static constexpr float PWLE_LEVEL_MAX = 1.0f; static constexpr float CS40L2X_PWLE_LEVEL_MAX = 0.99f; static constexpr float PWLE_FREQUENCY_RESOLUTION_HZ = 1.0f; -static constexpr float PWLE_FREQUENCY_MIN_HZ = 1.0f; +static constexpr float PWLE_FREQUENCY_MIN_HZ = 30.0f; static constexpr float RESONANT_FREQUENCY_DEFAULT = 145.0f; -static constexpr float PWLE_FREQUENCY_MAX_HZ = 999.0f; +static constexpr float PWLE_FREQUENCY_MAX_HZ = 300.0f; static constexpr float PWLE_BW_MAP_SIZE = 1 + ((PWLE_FREQUENCY_MAX_HZ - PWLE_FREQUENCY_MIN_HZ) / PWLE_FREQUENCY_RESOLUTION_HZ); static constexpr float RAMP_DOWN_CONSTANT = 1048.576f; -static constexpr float RAMP_DOWN_TIME_MS = 50.0f; +static constexpr float RAMP_DOWN_TIME_MS = 0.0f; static struct pcm_config haptic_nohost_config = { .channels = 1, @@ -128,13 +136,11 @@ static uint8_t amplitudeToScale(float amplitude, float maximum) { } // Discrete points of frequency:max_level pairs as recommended by the document -// [R4O6] Max. Allowable Chirp Levels (go/r4o6-max-chirp-levels) around resonant frequency #if defined(LUXSHARE_ICT_081545) static std::map<float, float> discretePwleMaxLevels = {{120.0, 0.4}, {130.0, 0.31}, {140.0, 0.14}, {145.0, 0.09}, {150.0, 0.15}, {160.0, 0.35}, {170.0, 0.4}}; // Discrete points of frequency:max_level pairs as recommended by the document -// [P7] Max. Allowable Chirp Levels (go/p7-max-chirp-levels) around resonant frequency #elif defined(LUXSHARE_ICT_LT_XLRA1906D) static std::map<float, float> discretePwleMaxLevels = {{145.0, 0.38}, {150.0, 0.35}, {160.0, 0.35}, {170.0, 0.15}, {180.0, 0.35}, {190.0, 0.35}, @@ -143,12 +149,10 @@ static std::map<float, float> discretePwleMaxLevels = {{145.0, 0.38}, {150.0, 0. static std::map<float, float> discretePwleMaxLevels = {}; #endif -// Initialize all limits to 0.4 according to the document [R4O6] Max. Allowable Chirp Levels -// (go/r4o6-max-chirp-levels) +// Initialize all limits to 0.4 according to the document Max. Allowable Chirp Levels #if defined(LUXSHARE_ICT_081545) std::vector<float> pwleMaxLevelLimitMap(PWLE_BW_MAP_SIZE, 0.4); -// Initialize all limits to 0.38 according to the document [P7] Max. Allowable Chirp Levels -// (go/p7-max-chirp-levels) +// Initialize all limits to 0.38 according to the document Max. Allowable Chirp Levels #elif defined(LUXSHARE_ICT_LT_XLRA1906D) std::vector<float> pwleMaxLevelLimitMap(PWLE_BW_MAP_SIZE, 0.38); #else @@ -156,6 +160,7 @@ std::vector<float> pwleMaxLevelLimitMap(PWLE_BW_MAP_SIZE, 1.0); #endif void Vibrator::createPwleMaxLevelLimitMap() { + HAPTICS_TRACE("createPwleMaxLevelLimitMap()"); int32_t capabilities; Vibrator::getCapabilities(&capabilities); if (capabilities & IVibrator::CAP_FREQUENCY_CONTROL) { @@ -183,8 +188,11 @@ void Vibrator::createPwleMaxLevelLimitMap() { float pwleMaxLevelLimitMapIdx = (itr0->first - PWLE_FREQUENCY_MIN_HZ) / PWLE_FREQUENCY_RESOLUTION_HZ; + // FixLater: avoid floating point loop counters + // NOLINTBEGIN(clang-analyzer-security.FloatLoopCounter,cert-flp30-c) for (float xp = x0; xp < (x1 + PWLE_FREQUENCY_RESOLUTION_HZ); xp += PWLE_FREQUENCY_RESOLUTION_HZ) { + // NOLINTEND(clang-analyzer-security.FloatLoopCounter,cert-flp30-c) float yp = y0 + ((y1 - y0) / (x1 - x0)) * (xp - x0); pwleMaxLevelLimitMap[pwleMaxLevelLimitMapIdx++] = yp; @@ -201,14 +209,19 @@ enum class AlwaysOnId : uint32_t { GPIO_FALL, }; -Vibrator::Vibrator(std::unique_ptr<HwApi> hwapi, std::unique_ptr<HwCal> hwcal) - : mHwApi(std::move(hwapi)), mHwCal(std::move(hwcal)), mAsyncHandle(std::async([] {})) { +Vibrator::Vibrator(std::unique_ptr<HwApi> hwapi, std::unique_ptr<HwCal> hwcal, + std::unique_ptr<StatsApi> statsapi) + : mHwApi(std::move(hwapi)), + mHwCal(std::move(hwcal)), + mStatsApi(std::move(statsapi)), + mAsyncHandle(std::async([] {})) { int32_t longFreqencyShift; uint32_t calVer; uint32_t caldata; uint32_t effectCount; if (!mHwApi->setState(true)) { + mStatsApi->logError(kHwApiError); ALOGE("Failed to set state (%d): %s", errno, strerror(errno)); } @@ -216,6 +229,7 @@ Vibrator::Vibrator(std::unique_ptr<HwApi> hwapi, std::unique_ptr<HwCal> hwcal) mHwApi->setF0(caldata); mResonantFrequency = static_cast<float>(caldata) / (1 << Q14_BIT_SHIFT); } else { + mStatsApi->logError(kHwApiError); ALOGE("Failed to get resonant frequency (%d): %s, using default resonant HZ: %f", errno, strerror(errno), RESONANT_FREQUENCY_DEFAULT); mResonantFrequency = RESONANT_FREQUENCY_DEFAULT; @@ -259,6 +273,7 @@ Vibrator::Vibrator(std::unique_ptr<HwApi> hwapi, std::unique_ptr<HwCal> hwcal) mHwCal->getClickVolLevels(&mClickEffectVol); mHwCal->getLongVolLevels(&mLongEffectVol); } + HAPTICS_TRACE("Vibrator(hwapi, hwcal:%u)", calVer); mHwApi->getEffectCount(&effectCount); mEffectDurations.resize(effectCount); @@ -273,20 +288,22 @@ Vibrator::Vibrator(std::unique_ptr<HwApi> hwapi, std::unique_ptr<HwCal> hwcal) mHwApi->setClabEnable(true); if (!(getPwleCompositionSizeMax(&mCompositionSizeMax).isOk())) { + mStatsApi->logError(kInitError); ALOGE("Failed to get pwle composition size max, using default size: %d", COMPOSE_PWLE_SIZE_LIMIT); mCompositionSizeMax = COMPOSE_PWLE_SIZE_LIMIT; } + mIsChirpEnabled = mHwCal->isChirpEnabled(); createPwleMaxLevelLimitMap(); mGenerateBandwidthAmplitudeMapDone = false; mBandwidthAmplitudeMap = generateBandwidthAmplitudeMap(); mIsUnderExternalControl = false; setPwleRampDown(); - mIsChirpEnabled = mHwCal->isChirpEnabled(); } ndk::ScopedAStatus Vibrator::getCapabilities(int32_t *_aidl_return) { + HAPTICS_TRACE("getCapabilities(_aidl_return)"); ATRACE_NAME("Vibrator::getCapabilities"); int32_t ret = IVibrator::CAP_ON_CALLBACK | IVibrator::CAP_PERFORM_CALLBACK | IVibrator::CAP_COMPOSE_EFFECTS | IVibrator::CAP_ALWAYS_ON_CONTROL | @@ -305,10 +322,13 @@ ndk::ScopedAStatus Vibrator::getCapabilities(int32_t *_aidl_return) { } ndk::ScopedAStatus Vibrator::off() { + HAPTICS_TRACE("off()"); ATRACE_NAME("Vibrator::off"); + ALOGD("off"); setGlobalAmplitude(false); mHwApi->setF0Offset(0); if (!mHwApi->setActivate(0)) { + mStatsApi->logError(kHwApiError); ALOGE("Failed to turn vibrator off (%d): %s", errno, strerror(errno)); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); } @@ -318,10 +338,14 @@ ndk::ScopedAStatus Vibrator::off() { ndk::ScopedAStatus Vibrator::on(int32_t timeoutMs, const std::shared_ptr<IVibratorCallback> &callback) { + HAPTICS_TRACE("on(timeoutMs:%u, callback)", timeoutMs); ATRACE_NAME("Vibrator::on"); + ALOGD("on"); + mStatsApi->logLatencyStart(kWaveformEffectLatency); const uint32_t index = timeoutMs < WAVEFORM_LONG_VIBRATION_THRESHOLD_MS ? WAVEFORM_SHORT_VIBRATION_EFFECT_INDEX : WAVEFORM_LONG_VIBRATION_EFFECT_INDEX; + mStatsApi->logWaveform(index, timeoutMs); if (MAX_COLD_START_LATENCY_MS <= UINT32_MAX - timeoutMs) { timeoutMs += MAX_COLD_START_LATENCY_MS; } @@ -333,17 +357,25 @@ ndk::ScopedAStatus Vibrator::on(int32_t timeoutMs, ndk::ScopedAStatus Vibrator::perform(Effect effect, EffectStrength strength, const std::shared_ptr<IVibratorCallback> &callback, int32_t *_aidl_return) { + HAPTICS_TRACE("perform(effect:%s, strength:%s, callback, _aidl_return)", + toString(effect).c_str(), toString(strength).c_str()); ATRACE_NAME("Vibrator::perform"); + ALOGD("perform"); + + mStatsApi->logLatencyStart(kPrebakedEffectLatency); + return performEffect(effect, strength, callback, _aidl_return); } ndk::ScopedAStatus Vibrator::getSupportedEffects(std::vector<Effect> *_aidl_return) { + HAPTICS_TRACE("getSupportedEffects(_aidl_return)"); *_aidl_return = {Effect::TEXTURE_TICK, Effect::TICK, Effect::CLICK, Effect::HEAVY_CLICK, Effect::DOUBLE_CLICK}; return ndk::ScopedAStatus::ok(); } ndk::ScopedAStatus Vibrator::setAmplitude(float amplitude) { + HAPTICS_TRACE("setAmplitude(amplitude:%f)", amplitude); ATRACE_NAME("Vibrator::setAmplitude"); if (amplitude <= 0.0f || amplitude > 1.0f) { return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); @@ -352,11 +384,13 @@ ndk::ScopedAStatus Vibrator::setAmplitude(float amplitude) { if (!isUnderExternalControl()) { return setEffectAmplitude(amplitude, 1.0); } else { + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } } ndk::ScopedAStatus Vibrator::setExternalControl(bool enabled) { + HAPTICS_TRACE("setExternalControl(enabled:%u)", enabled); ATRACE_NAME("Vibrator::setExternalControl"); setGlobalAmplitude(enabled); @@ -365,6 +399,7 @@ ndk::ScopedAStatus Vibrator::setExternalControl(bool enabled) { ALOGE("Restart the external process."); if (mHasHapticAlsaDevice) { if (!enableHapticPcmAmp(&mHapticPcm, !enabled, mCard, mDevice)) { + mStatsApi->logError(kAlsaFailError); ALOGE("Failed to %s haptic pcm device: %d", (enabled ? "enable" : "disable"), mDevice); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); @@ -372,6 +407,7 @@ ndk::ScopedAStatus Vibrator::setExternalControl(bool enabled) { } if (mHwApi->hasAspEnable()) { if (!mHwApi->setAspEnable(!enabled)) { + mStatsApi->logError(kHwApiError); ALOGE("Failed to set external control (%d): %s", errno, strerror(errno)); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); } @@ -383,12 +419,14 @@ ndk::ScopedAStatus Vibrator::setExternalControl(bool enabled) { } if (mHasHapticAlsaDevice) { if (!enableHapticPcmAmp(&mHapticPcm, enabled, mCard, mDevice)) { + mStatsApi->logError(kAlsaFailError); ALOGE("Failed to %s haptic pcm device: %d", (enabled ? "enable" : "disable"), mDevice); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); } } if (mHwApi->hasAspEnable()) { if (!mHwApi->setAspEnable(enabled)) { + mStatsApi->logError(kHwApiError); ALOGE("Failed to set external control (%d): %s", errno, strerror(errno)); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); } @@ -399,18 +437,21 @@ ndk::ScopedAStatus Vibrator::setExternalControl(bool enabled) { } ndk::ScopedAStatus Vibrator::getCompositionDelayMax(int32_t *maxDelayMs) { + HAPTICS_TRACE("getCompositionDelayMax(maxDelayMs)"); ATRACE_NAME("Vibrator::getCompositionDelayMax"); *maxDelayMs = COMPOSE_DELAY_MAX_MS; return ndk::ScopedAStatus::ok(); } ndk::ScopedAStatus Vibrator::getCompositionSizeMax(int32_t *maxSize) { + HAPTICS_TRACE("getCompositionSizeMax(maxSize)"); ATRACE_NAME("Vibrator::getCompositionSizeMax"); *maxSize = COMPOSE_SIZE_MAX; return ndk::ScopedAStatus::ok(); } ndk::ScopedAStatus Vibrator::getSupportedPrimitives(std::vector<CompositePrimitive> *supported) { + HAPTICS_TRACE("getSupportedPrimitives(supported)"); *supported = { CompositePrimitive::NOOP, CompositePrimitive::CLICK, CompositePrimitive::THUD, CompositePrimitive::SPIN, @@ -423,6 +464,7 @@ ndk::ScopedAStatus Vibrator::getSupportedPrimitives(std::vector<CompositePrimiti ndk::ScopedAStatus Vibrator::getPrimitiveDuration(CompositePrimitive primitive, int32_t *durationMs) { + HAPTICS_TRACE("getPrimitiveDuration(primitive:%s, durationMs)", toString(primitive).c_str()); ndk::ScopedAStatus status; uint32_t effectIndex; @@ -442,39 +484,54 @@ ndk::ScopedAStatus Vibrator::getPrimitiveDuration(CompositePrimitive primitive, ndk::ScopedAStatus Vibrator::compose(const std::vector<CompositeEffect> &composite, const std::shared_ptr<IVibratorCallback> &callback) { + HAPTICS_TRACE("compose(composite, callback)"); ATRACE_NAME("Vibrator::compose"); + ALOGD("compose"); std::ostringstream effectBuilder; std::string effectQueue; + mStatsApi->logLatencyStart(kCompositionEffectLatency); + if (composite.size() > COMPOSE_SIZE_MAX) { + mStatsApi->logError(kBadCompositeError); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } + const std::scoped_lock<std::mutex> lock(mTotalDurationMutex); + // Reset the mTotalDuration + mTotalDuration = 0; for (auto &e : composite) { if (e.scale < 0.0f || e.scale > 1.0f) { + mStatsApi->logError(kBadCompositeError); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } if (e.delayMs) { if (e.delayMs > COMPOSE_DELAY_MAX_MS) { + mStatsApi->logError(kBadCompositeError); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } effectBuilder << e.delayMs << ","; + mTotalDuration += e.delayMs; } if (e.primitive != CompositePrimitive::NOOP) { ndk::ScopedAStatus status; uint32_t effectIndex; status = getPrimitiveDetails(e.primitive, &effectIndex); + mStatsApi->logPrimitive(effectIndex); if (!status.isOk()) { + mStatsApi->logError(kBadCompositeError); return status; } effectBuilder << effectIndex << "." << intensityToVolLevel(e.scale, effectIndex) << ","; + mTotalDuration += mEffectDurations[effectIndex]; } } if (effectBuilder.tellp() == 0) { + mStatsApi->logError(kComposeFailError); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } @@ -487,19 +544,30 @@ ndk::ScopedAStatus Vibrator::compose(const std::vector<CompositeEffect> &composi ndk::ScopedAStatus Vibrator::on(uint32_t timeoutMs, uint32_t effectIndex, const std::shared_ptr<IVibratorCallback> &callback) { + HAPTICS_TRACE("on(timeoutMs:%u, effectIndex:%u, callback)", timeoutMs, effectIndex); if (isUnderExternalControl()) { setExternalControl(false); ALOGE("Device is under external control mode. Force to disable it to prevent chip hang " "problem."); } if (mAsyncHandle.wait_for(ASYNC_COMPLETION_TIMEOUT) != std::future_status::ready) { + mStatsApi->logError(kAsyncFailError); ALOGE("Previous vibration pending: prev: %d, curr: %d", mActiveId, effectIndex); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); } + ALOGD("on"); mHwApi->setEffectIndex(effectIndex); mHwApi->setDuration(timeoutMs); + mStatsApi->logLatencyEnd(); mHwApi->setActivate(1); + // Using the mToalDuration for composed effect. + // For composed effect, we set the UINT32_MAX to the duration sysfs node, + // but it not a practical way to use it to monitor the total duration time. + if (timeoutMs != UINT32_MAX) { + const std::scoped_lock<std::mutex> lock(mTotalDurationMutex); + mTotalDuration = timeoutMs; + } mActiveId = effectIndex; @@ -509,9 +577,11 @@ ndk::ScopedAStatus Vibrator::on(uint32_t timeoutMs, uint32_t effectIndex, } ndk::ScopedAStatus Vibrator::setEffectAmplitude(float amplitude, float maximum) { + HAPTICS_TRACE("setEffectAmplitude(amplitude:%f, maximum:%f)", amplitude, maximum); int32_t scale = amplitudeToScale(amplitude, maximum); if (!mHwApi->setEffectScale(scale)) { + mStatsApi->logError(kHwApiError); ALOGE("Failed to set effect amplitude (%d): %s", errno, strerror(errno)); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); } @@ -520,10 +590,12 @@ ndk::ScopedAStatus Vibrator::setEffectAmplitude(float amplitude, float maximum) } ndk::ScopedAStatus Vibrator::setGlobalAmplitude(bool set) { + HAPTICS_TRACE("setGlobalAmplitude(set:%u)", set); uint8_t amplitude = set ? mLongEffectVol[1] : VOLTAGE_SCALE_MAX; int32_t scale = amplitudeToScale(amplitude, VOLTAGE_SCALE_MAX); if (!mHwApi->setGlobalScale(scale)) { + mStatsApi->logError(kHwApiError); ALOGE("Failed to set global amplitude (%d): %s", errno, strerror(errno)); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); } @@ -532,11 +604,14 @@ ndk::ScopedAStatus Vibrator::setGlobalAmplitude(bool set) { } ndk::ScopedAStatus Vibrator::getSupportedAlwaysOnEffects(std::vector<Effect> *_aidl_return) { + HAPTICS_TRACE("getSupportedAlwaysOnEffects(_aidl_return)"); *_aidl_return = {Effect::TEXTURE_TICK, Effect::TICK, Effect::CLICK, Effect::HEAVY_CLICK}; return ndk::ScopedAStatus::ok(); } ndk::ScopedAStatus Vibrator::alwaysOnEnable(int32_t id, Effect effect, EffectStrength strength) { + HAPTICS_TRACE("alwaysOnEnable(id:%d, effect:%s, strength:%s)", id, toString(effect).c_str(), + toString(strength).c_str()); ndk::ScopedAStatus status; uint32_t effectIndex; uint32_t timeMs; @@ -561,9 +636,12 @@ ndk::ScopedAStatus Vibrator::alwaysOnEnable(int32_t id, Effect effect, EffectStr return ndk::ScopedAStatus::ok(); } + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } + ndk::ScopedAStatus Vibrator::alwaysOnDisable(int32_t id) { + HAPTICS_TRACE("alwaysOnDisable(id: %d)", id); switch (static_cast<AlwaysOnId>(id)) { case AlwaysOnId::GPIO_RISE: mHwApi->setGpioRiseIndex(0); @@ -573,18 +651,22 @@ ndk::ScopedAStatus Vibrator::alwaysOnDisable(int32_t id) { return ndk::ScopedAStatus::ok(); } + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } ndk::ScopedAStatus Vibrator::getResonantFrequency(float *resonantFreqHz) { + HAPTICS_TRACE("getResonantFrequency(resonantFreqHz)"); *resonantFreqHz = mResonantFrequency; return ndk::ScopedAStatus::ok(); } ndk::ScopedAStatus Vibrator::getQFactor(float *qFactor) { + HAPTICS_TRACE("getQFactor(qFactor)"); uint32_t caldata; if (!mHwCal->getQ(&caldata)) { + mStatsApi->logError(kHwCalError); ALOGE("Failed to get q factor (%d): %s", errno, strerror(errno)); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); } @@ -594,32 +676,38 @@ ndk::ScopedAStatus Vibrator::getQFactor(float *qFactor) { } ndk::ScopedAStatus Vibrator::getFrequencyResolution(float *freqResolutionHz) { + HAPTICS_TRACE("getFrequencyResolution(freqResolutionHz)"); int32_t capabilities; Vibrator::getCapabilities(&capabilities); if (capabilities & IVibrator::CAP_FREQUENCY_CONTROL) { *freqResolutionHz = PWLE_FREQUENCY_RESOLUTION_HZ; return ndk::ScopedAStatus::ok(); } else { + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } } ndk::ScopedAStatus Vibrator::getFrequencyMinimum(float *freqMinimumHz) { + HAPTICS_TRACE("getFrequencyMinimum(freqMinimumHz)"); int32_t capabilities; Vibrator::getCapabilities(&capabilities); if (capabilities & IVibrator::CAP_FREQUENCY_CONTROL) { *freqMinimumHz = PWLE_FREQUENCY_MIN_HZ; return ndk::ScopedAStatus::ok(); } else { + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } } static float redcToFloat(uint32_t redcMeasured) { + HAPTICS_TRACE("redcToFloat(redcMeasured: %u)", redcMeasured); return redcMeasured * 5.857 / (1 << Q17_BIT_SHIFT); } std::vector<float> Vibrator::generateBandwidthAmplitudeMap() { + HAPTICS_TRACE("generateBandwidthAmplitudeMap()"); // Use constant Q Factor of 10 from HW's suggestion const float qFactor = 10.0f; const float blSys = 1.1f; @@ -630,12 +718,14 @@ std::vector<float> Vibrator::generateBandwidthAmplitudeMap() { mHwCal->getDeviceMass(&deviceMass); mHwCal->getLocCoeff(&locCoeff); if (!deviceMass || !locCoeff) { + mStatsApi->logError(kInitError); ALOGE("Failed to get Device Mass: %f and Loc Coeff: %f", deviceMass, locCoeff); return std::vector<float>(); } // Resistance value need to be retrieved from calibration file if (!mRedc) { + mStatsApi->logError(kInitError); ALOGE("Failed to get redc"); return std::vector<float>(); } @@ -684,6 +774,7 @@ std::vector<float> Vibrator::generateBandwidthAmplitudeMap() { } ndk::ScopedAStatus Vibrator::getBandwidthAmplitudeMap(std::vector<float> *_aidl_return) { + HAPTICS_TRACE("getBandwidthAmplitudeMap(_aidl_return)"); int32_t capabilities; Vibrator::getCapabilities(&capabilities); if (capabilities & IVibrator::CAP_FREQUENCY_CONTROL) { @@ -695,27 +786,32 @@ ndk::ScopedAStatus Vibrator::getBandwidthAmplitudeMap(std::vector<float> *_aidl_ ? ndk::ScopedAStatus::ok() : ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); } else { + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } } ndk::ScopedAStatus Vibrator::getPwlePrimitiveDurationMax(int32_t *durationMs) { + HAPTICS_TRACE("getPwlePrimitiveDurationMax(durationMs)"); int32_t capabilities; Vibrator::getCapabilities(&capabilities); if (capabilities & IVibrator::CAP_COMPOSE_PWLE_EFFECTS) { *durationMs = COMPOSE_PWLE_PRIMITIVE_DURATION_MAX_MS; return ndk::ScopedAStatus::ok(); } else { + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } } ndk::ScopedAStatus Vibrator::getPwleCompositionSizeMax(int32_t *maxSize) { + HAPTICS_TRACE("getPwleCompositionSizeMax(maxSize)"); int32_t capabilities; Vibrator::getCapabilities(&capabilities); if (capabilities & IVibrator::CAP_COMPOSE_PWLE_EFFECTS) { uint32_t segments; if (!mHwApi->getAvailablePwleSegments(&segments)) { + mStatsApi->logError(kHwApiError); ALOGE("Failed to get availablePwleSegments (%d): %s", errno, strerror(errno)); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); } @@ -723,11 +819,13 @@ ndk::ScopedAStatus Vibrator::getPwleCompositionSizeMax(int32_t *maxSize) { mCompositionSizeMax = *maxSize; return ndk::ScopedAStatus::ok(); } else { + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } } ndk::ScopedAStatus Vibrator::getSupportedBraking(std::vector<Braking> *supported) { + HAPTICS_TRACE("getSupportedBraking(supported)"); int32_t capabilities; Vibrator::getCapabilities(&capabilities); if (capabilities & IVibrator::CAP_COMPOSE_PWLE_EFFECTS) { @@ -737,12 +835,15 @@ ndk::ScopedAStatus Vibrator::getSupportedBraking(std::vector<Braking> *supported }; return ndk::ScopedAStatus::ok(); } else { + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } } ndk::ScopedAStatus Vibrator::setPwle(const std::string &pwleQueue) { + HAPTICS_TRACE("setPwle(pwleQueue:%s)", pwleQueue.c_str()); if (!mHwApi->setPwle(pwleQueue)) { + mStatsApi->logError(kHwApiError); ALOGE("Failed to write \"%s\" to pwle (%d): %s", pwleQueue.c_str(), errno, strerror(errno)); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); } @@ -755,6 +856,7 @@ static void incrementIndex(int *index) { } static void constructActiveDefaults(std::ostringstream &pwleBuilder, const int &segmentIdx) { + HAPTICS_TRACE("constructActiveDefaults(pwleBuilder, segmentIdx:%d)", segmentIdx); pwleBuilder << ",C" << segmentIdx << ":1"; pwleBuilder << ",B" << segmentIdx << ":0"; pwleBuilder << ",AR" << segmentIdx << ":0"; @@ -763,6 +865,10 @@ static void constructActiveDefaults(std::ostringstream &pwleBuilder, const int & static void constructActiveSegment(std::ostringstream &pwleBuilder, const int &segmentIdx, int duration, float amplitude, float frequency) { + HAPTICS_TRACE( + "constructActiveSegment(pwleBuilder, segmentIdx:%d, duration:%d, amplitude:%f, " + "frequency:%f)", + segmentIdx, duration, amplitude, frequency); pwleBuilder << ",T" << segmentIdx << ":" << duration; pwleBuilder << ",L" << segmentIdx << ":" << std::setprecision(1) << amplitude; pwleBuilder << ",F" << segmentIdx << ":" << std::lroundf(frequency); @@ -771,6 +877,10 @@ static void constructActiveSegment(std::ostringstream &pwleBuilder, const int &s static void constructBrakingSegment(std::ostringstream &pwleBuilder, const int &segmentIdx, int duration, Braking brakingType, float frequency) { + HAPTICS_TRACE( + "constructActiveSegment(pwleBuilder, segmentIdx:%d, duration:%d, brakingType:%s, " + "frequency:%f)", + segmentIdx, duration, toString(brakingType).c_str(), frequency); pwleBuilder << ",T" << segmentIdx << ":" << duration; pwleBuilder << ",L" << segmentIdx << ":" << 0; pwleBuilder << ",F" << segmentIdx << ":" << std::lroundf(frequency); @@ -783,15 +893,20 @@ static void constructBrakingSegment(std::ostringstream &pwleBuilder, const int & ndk::ScopedAStatus Vibrator::composePwle(const std::vector<PrimitivePwle> &composite, const std::shared_ptr<IVibratorCallback> &callback) { + HAPTICS_TRACE("composePwle(composite, callback)"); ATRACE_NAME("Vibrator::composePwle"); std::ostringstream pwleBuilder; std::string pwleQueue; + mStatsApi->logLatencyStart(kPwleEffectLatency); + if (!mIsChirpEnabled) { + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } if (composite.size() <= 0 || composite.size() > mCompositionSizeMax) { + mStatsApi->logError(kBadCompositeError); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } @@ -809,11 +924,13 @@ ndk::ScopedAStatus Vibrator::composePwle(const std::vector<PrimitivePwle> &compo auto active = e.get<PrimitivePwle::active>(); if (active.duration < 0 || active.duration > COMPOSE_PWLE_PRIMITIVE_DURATION_MAX_MS) { + mStatsApi->logError(kBadCompositeError); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } if (active.startAmplitude < PWLE_LEVEL_MIN || active.startAmplitude > PWLE_LEVEL_MAX || active.endAmplitude < PWLE_LEVEL_MIN || active.endAmplitude > PWLE_LEVEL_MAX) { + mStatsApi->logError(kBadCompositeError); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } if (active.startAmplitude > CS40L2X_PWLE_LEVEL_MAX) { @@ -827,6 +944,7 @@ ndk::ScopedAStatus Vibrator::composePwle(const std::vector<PrimitivePwle> &compo active.startFrequency > PWLE_FREQUENCY_MAX_HZ || active.endFrequency < PWLE_FREQUENCY_MIN_HZ || active.endFrequency > PWLE_FREQUENCY_MAX_HZ) { + mStatsApi->logError(kBadCompositeError); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } @@ -861,9 +979,11 @@ ndk::ScopedAStatus Vibrator::composePwle(const std::vector<PrimitivePwle> &compo case PrimitivePwle::braking: { auto braking = e.get<PrimitivePwle::braking>(); if (braking.braking > Braking::CLAB) { + mStatsApi->logError(kBadPrimitiveError); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } if (braking.duration > COMPOSE_PWLE_PRIMITIVE_DURATION_MAX_MS) { + mStatsApi->logError(kBadPrimitiveError); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } @@ -883,11 +1003,13 @@ ndk::ScopedAStatus Vibrator::composePwle(const std::vector<PrimitivePwle> &compo if (pwleQueue.size() > CS40L2X_PWLE_LENGTH_MAX) { ALOGE("PWLE string too large(%u)", static_cast<uint32_t>(pwleQueue.size())); + mStatsApi->logError(kPwleConstructionFailError); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); } else { ALOGD("PWLE string : %u", static_cast<uint32_t>(pwleQueue.size())); ndk::ScopedAStatus status = setPwle(pwleQueue); if (!status.isOk()) { + mStatsApi->logError(kPwleConstructionFailError); ALOGE("Failed to write pwle queue"); return status; } @@ -897,7 +1019,12 @@ ndk::ScopedAStatus Vibrator::composePwle(const std::vector<PrimitivePwle> &compo totalDuration += MAX_COLD_START_LATENCY_MS; mHwApi->setDuration(totalDuration); + { + const std::scoped_lock<std::mutex> lock(mTotalDurationMutex); + mTotalDuration = totalDuration; + } + mStatsApi->logLatencyEnd(); mHwApi->setActivate(1); mAsyncHandle = std::async(&Vibrator::waitForComplete, this, callback); @@ -906,10 +1033,12 @@ ndk::ScopedAStatus Vibrator::composePwle(const std::vector<PrimitivePwle> &compo } bool Vibrator::isUnderExternalControl() { + HAPTICS_TRACE("isUnderExternalControl()"); return mIsUnderExternalControl; } binder_status_t Vibrator::dump(int fd, const char **args, uint32_t numArgs) { + HAPTICS_TRACE("dump(fd:%d, args, numArgs:%u)", fd, numArgs); if (fd < 0) { ALOGE("Called debug() with invalid fd."); return STATUS_OK; @@ -944,6 +1073,10 @@ binder_status_t Vibrator::dump(int fd, const char **args, uint32_t numArgs) { mHwCal->debug(fd); + dprintf(fd, "\n"); + + mStatsApi->debug(fd); + fsync(fd); return STATUS_OK; } @@ -951,6 +1084,10 @@ binder_status_t Vibrator::dump(int fd, const char **args, uint32_t numArgs) { ndk::ScopedAStatus Vibrator::getSimpleDetails(Effect effect, EffectStrength strength, uint32_t *outEffectIndex, uint32_t *outTimeMs, uint32_t *outVolLevel) { + HAPTICS_TRACE( + "getSimpleDetails(effect:%s, strength:%s, outEffectIndex, outTimeMs" + ", outVolLevel)", + toString(effect).c_str(), toString(strength).c_str()); uint32_t effectIndex; uint32_t timeMs; float intensity; @@ -967,6 +1104,7 @@ ndk::ScopedAStatus Vibrator::getSimpleDetails(Effect effect, EffectStrength stre intensity = 1.0f; break; default: + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } @@ -988,11 +1126,16 @@ ndk::ScopedAStatus Vibrator::getSimpleDetails(Effect effect, EffectStrength stre intensity *= 1.0f; break; default: + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } volLevel = intensityToVolLevel(intensity, effectIndex); timeMs = mEffectDurations[effectIndex] + MAX_COLD_START_LATENCY_MS; + { + const std::scoped_lock<std::mutex> lock(mTotalDurationMutex); + mTotalDuration = timeMs; + } *outEffectIndex = effectIndex; *outTimeMs = timeMs; @@ -1004,6 +1147,9 @@ ndk::ScopedAStatus Vibrator::getSimpleDetails(Effect effect, EffectStrength stre ndk::ScopedAStatus Vibrator::getCompoundDetails(Effect effect, EffectStrength strength, uint32_t *outTimeMs, uint32_t * /*outVolLevel*/, std::string *outEffectQueue) { + HAPTICS_TRACE( + "getCompoundDetails(effect:%s, strength:%s, outTimeMs, outVolLevel, outEffectQueue)", + toString(effect).c_str(), toString(strength).c_str()); ndk::ScopedAStatus status; uint32_t timeMs; std::ostringstream effectBuilder; @@ -1037,9 +1183,14 @@ ndk::ScopedAStatus Vibrator::getCompoundDetails(Effect effect, EffectStrength st } effectBuilder << thisEffectIndex << "." << thisVolLevel; timeMs += thisTimeMs; + { + const std::scoped_lock<std::mutex> lock(mTotalDurationMutex); + mTotalDuration = timeMs; + } break; default: + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } @@ -1051,6 +1202,7 @@ ndk::ScopedAStatus Vibrator::getCompoundDetails(Effect effect, EffectStrength st ndk::ScopedAStatus Vibrator::getPrimitiveDetails(CompositePrimitive primitive, uint32_t *outEffectIndex) { + HAPTICS_TRACE("getPrimitiveDetails(primitive:%s, outEffectIndex)", toString(primitive).c_str()); uint32_t effectIndex; switch (primitive) { @@ -1081,6 +1233,7 @@ ndk::ScopedAStatus Vibrator::getPrimitiveDetails(CompositePrimitive primitive, effectIndex = WAVEFORM_LOW_TICK_INDEX; break; default: + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } @@ -1090,9 +1243,11 @@ ndk::ScopedAStatus Vibrator::getPrimitiveDetails(CompositePrimitive primitive, } ndk::ScopedAStatus Vibrator::setEffectQueue(const std::string &effectQueue) { + HAPTICS_TRACE("setEffectQueue(effectQueue:%s)", effectQueue.c_str()); if (!mHwApi->setEffectQueue(effectQueue)) { ALOGE("Failed to write \"%s\" to effect queue (%d): %s", effectQueue.c_str(), errno, strerror(errno)); + mStatsApi->logError(kHwApiError); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); } @@ -1102,6 +1257,8 @@ ndk::ScopedAStatus Vibrator::setEffectQueue(const std::string &effectQueue) { ndk::ScopedAStatus Vibrator::performEffect(Effect effect, EffectStrength strength, const std::shared_ptr<IVibratorCallback> &callback, int32_t *outTimeMs) { + HAPTICS_TRACE("performEffect(effect:%s, strength:%s, callback, outTimeMs)", + toString(effect).c_str(), toString(strength).c_str()); ndk::ScopedAStatus status; uint32_t effectIndex; uint32_t timeMs = 0; @@ -1122,6 +1279,7 @@ ndk::ScopedAStatus Vibrator::performEffect(Effect effect, EffectStrength strengt status = getCompoundDetails(effect, strength, &timeMs, &volLevel, &effectQueue); break; default: + mStatsApi->logError(kUnsupportedOpError); status = ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); break; } @@ -1140,6 +1298,8 @@ exit: ndk::ScopedAStatus Vibrator::performEffect(uint32_t effectIndex, uint32_t volLevel, const std::string *effectQueue, const std::shared_ptr<IVibratorCallback> &callback) { + HAPTICS_TRACE("performEffect(effectIndex:%u, volLevel:%u, effectQueue:%s, callback)", + effectIndex, volLevel, effectQueue->c_str()); if (effectQueue && !effectQueue->empty()) { ndk::ScopedAStatus status = setEffectQueue(*effectQueue); if (!status.isOk()) { @@ -1155,18 +1315,33 @@ ndk::ScopedAStatus Vibrator::performEffect(uint32_t effectIndex, uint32_t volLev } void Vibrator::waitForComplete(std::shared_ptr<IVibratorCallback> &&callback) { - mHwApi->pollVibeState(false); + HAPTICS_TRACE("waitForComplete(callback)"); + ALOGD("waitForComplete"); + uint32_t duration; + { + const std::scoped_lock<std::mutex> lock(mTotalDurationMutex); + duration = ((mTotalDuration + POLLING_TIMEOUT) < UINT32_MAX) + ? mTotalDuration + POLLING_TIMEOUT + : UINT32_MAX; + } + if (!mHwApi->pollVibeState(false, duration)) { + ALOGE("Timeout(%u)! Fail to poll STOP state", duration); + } else { + ALOGD("waitForComplete: Get STOP! Set active to 0."); + } mHwApi->setActivate(false); if (callback) { auto ret = callback->onComplete(); if (!ret.isOk()) { + mStatsApi->logError(kAsyncFailError); ALOGE("Failed completion callback: %d", ret.getExceptionCode()); } } } uint32_t Vibrator::intensityToVolLevel(float intensity, uint32_t effectIndex) { + HAPTICS_TRACE("intensityToVolLevel(intensity:%f, effectIndex:%u)", intensity, effectIndex); uint32_t volLevel; auto calc = [](float intst, std::array<uint32_t, 2> v) -> uint32_t { return std::lround(intst * (v[1] - v[0])) + v[0]; }; @@ -1197,6 +1372,7 @@ uint32_t Vibrator::intensityToVolLevel(float intensity, uint32_t effectIndex) { } bool Vibrator::findHapticAlsaDevice(int *card, int *device) { + HAPTICS_TRACE("findHapticAlsaDevice(card, device)"); std::string line; std::ifstream myfile(PROC_SND_PCM); if (myfile.is_open()) { @@ -1211,12 +1387,14 @@ bool Vibrator::findHapticAlsaDevice(int *card, int *device) { } myfile.close(); } else { + mStatsApi->logError(kAlsaFailError); ALOGE("Failed to read file: %s", PROC_SND_PCM); } return false; } bool Vibrator::hasHapticAlsaDevice() { + HAPTICS_TRACE("hasHapticAlsaDevice()"); // We need to call findHapticAlsaDevice once only. Calling in the // constructor is too early in the boot process and the pcm file contents // are empty. Hence we make the call here once only right before we need to. @@ -1226,6 +1404,7 @@ bool Vibrator::hasHapticAlsaDevice() { mHasHapticAlsaDevice = true; configHapticAlsaDeviceDone = true; } else { + mStatsApi->logError(kAlsaFailError); ALOGE("Haptic ALSA device not supported"); } } @@ -1233,6 +1412,7 @@ bool Vibrator::hasHapticAlsaDevice() { } bool Vibrator::enableHapticPcmAmp(struct pcm **haptic_pcm, bool enable, int card, int device) { + HAPTICS_TRACE("enableHapticPcmAmp(pcm, enable:%u, card:%d, device:%d)", enable, card, device); int ret = 0; if (enable) { @@ -1270,18 +1450,27 @@ fail: } void Vibrator::setPwleRampDown() { + HAPTICS_TRACE("setPwleRampDown()"); // The formula for calculating the ramp down coefficient to be written into // pwle_ramp_down is as follows: // Crd = 1048.576 / Trd // where Trd is the desired ramp down time in seconds // pwle_ramp_down accepts only 24 bit integers values - const float seconds = RAMP_DOWN_TIME_MS / 1000; - const auto ramp_down_coefficient = static_cast<uint32_t>(RAMP_DOWN_CONSTANT / seconds); - - if (!mHwApi->setPwleRampDown(ramp_down_coefficient)) { - ALOGE("Failed to write \"%d\" to pwle_ramp_down (%d): %s", ramp_down_coefficient, errno, - strerror(errno)); + if (RAMP_DOWN_TIME_MS != 0.0) { + const float seconds = RAMP_DOWN_TIME_MS / 1000; + const auto ramp_down_coefficient = static_cast<uint32_t>(RAMP_DOWN_CONSTANT / seconds); + if (!mHwApi->setPwleRampDown(ramp_down_coefficient)) { + mStatsApi->logError(kHwApiError); + ALOGE("Failed to write \"%d\" to pwle_ramp_down (%d): %s", ramp_down_coefficient, errno, + strerror(errno)); + } + } else { + // Turn off the low level PWLE Ramp Down feature + if (!mHwApi->setPwleRampDown(0)) { + mStatsApi->logError(kHwApiError); + ALOGE("Failed to write 0 to pwle_ramp_down (%d): %s", errno, strerror(errno)); + } } } diff --git a/vibrator/cs40l25/Vibrator.h b/vibrator/cs40l25/Vibrator.h index 70543e30..72908056 100644 --- a/vibrator/cs40l25/Vibrator.h +++ b/vibrator/cs40l25/Vibrator.h @@ -89,9 +89,9 @@ class Vibrator : public BnVibrator { // Indicates the number of 0.125-dB steps of attenuation to apply to // waveforms triggered in response to a GPIO1 rising edge. virtual bool setGpioRiseScale(uint32_t value) = 0; - // Blocks until vibrator reaches desired state + // Blocks until timeout or vibrator reaches desired state // (true = enabled, false = disabled). - virtual bool pollVibeState(bool value) = 0; + virtual bool pollVibeState(uint32_t value, int32_t timeoutMs = -1) = 0; // Enables/disables closed-loop active braking. virtual bool setClabEnable(bool value) = 0; // Reports the number of available PWLE segments. @@ -143,8 +143,27 @@ class Vibrator : public BnVibrator { virtual void debug(int fd) = 0; }; + // APIs for logging data to statistics backend + class StatsApi { + public: + virtual ~StatsApi() = default; + // Increment count for effect + virtual bool logPrimitive(uint16_t effectIndex) = 0; + // Increment count for long/short waveform and duration bucket + virtual bool logWaveform(uint16_t effectIndex, int32_t duration) = 0; + // Increment count for error + virtual bool logError(uint16_t errorIndex) = 0; + // Start new latency measurement + virtual bool logLatencyStart(uint16_t latencyIndex) = 0; + // Finish latency measurement and update latency statistics with result + virtual bool logLatencyEnd() = 0; + // Emit diagnostic information to the given file. + virtual void debug(int fd) = 0; + }; + public: - Vibrator(std::unique_ptr<HwApi> hwapi, std::unique_ptr<HwCal> hwcal); + Vibrator(std::unique_ptr<HwApi> hwapi, std::unique_ptr<HwCal> hwcal, + std::unique_ptr<StatsApi> statsapi); ndk::ScopedAStatus getCapabilities(int32_t *_aidl_return) override; ndk::ScopedAStatus off() override; @@ -214,6 +233,7 @@ class Vibrator : public BnVibrator { std::unique_ptr<HwApi> mHwApi; std::unique_ptr<HwCal> mHwCal; + std::unique_ptr<StatsApi> mStatsApi; uint32_t mF0Offset; std::array<uint32_t, 2> mTickEffectVol; std::array<uint32_t, 2> mClickEffectVol; @@ -232,6 +252,8 @@ class Vibrator : public BnVibrator { bool mIsChirpEnabled; std::vector<float> mBandwidthAmplitudeMap; bool mGenerateBandwidthAmplitudeMapDone; + uint32_t mTotalDuration{0}; + std::mutex mTotalDurationMutex; }; } // namespace vibrator diff --git a/vibrator/cs40l25/android.hardware.vibrator-service.cs40l25.rc b/vibrator/cs40l25/android.hardware.vibrator-service.cs40l25.rc index f373d31f..13834efc 100644 --- a/vibrator/cs40l25/android.hardware.vibrator-service.cs40l25.rc +++ b/vibrator/cs40l25/android.hardware.vibrator-service.cs40l25.rc @@ -71,7 +71,10 @@ service vendor.vibrator.cs40l25 /vendor/bin/hw/android.hardware.vibrator-service device/pwle_ramp_down device/q_stored device/redc_stored + device/vibe_state state " + setenv STATS_INSTANCE default + disabled diff --git a/vibrator/cs40l25/bench/Stats.h b/vibrator/cs40l25/bench/Stats.h new file mode 100644 index 00000000..81f62348 --- /dev/null +++ b/vibrator/cs40l25/bench/Stats.h @@ -0,0 +1,220 @@ +/* + * 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. + */ +#pragma once + +#include <log/log.h> +#include <utils/Trace.h> + +#include <algorithm> +#include <chrono> +#include <mutex> + +#include "Vibrator.h" + +constexpr int32_t DURATION_BUCKET_WIDTH = 50; +constexpr int32_t DURATION_50MS_BUCKET_COUNT = 20; +constexpr int32_t DURATION_BUCKET_COUNT = DURATION_50MS_BUCKET_COUNT + 1; +constexpr uint32_t MAX_TIME_MS = UINT16_MAX; + +namespace aidl { +namespace android { +namespace hardware { +namespace vibrator { + +enum EffectLatency : uint16_t { + kPrebakedEffectLatency = 0, + kCompositionEffectLatency, + kPwleEffectLatency, + + kEffectLatencyCount +}; + +enum VibratorError : uint16_t { + kInitError = 0, + kHwApiError, + kHwCalError, + kComposeFailError, + kAlsaFailError, + kAsyncFailError, + kBadTimeoutError, + kBadAmplitudeError, + kBadEffectError, + kBadEffectStrengthError, + kBadPrimitiveError, + kBadCompositeError, + kPwleConstructionFailError, + kUnsupportedOpError, + + kVibratorErrorCount +}; + +class StatsApi : public Vibrator::StatsApi { + private: + static constexpr uint32_t BASE_CONTINUOUS_EFFECT_OFFSET = 32768; + enum WaveformIndex : uint16_t { + /* Physical waveform */ + WAVEFORM_LONG_VIBRATION_EFFECT_INDEX = 0, + WAVEFORM_RESERVED_INDEX_1 = 1, + WAVEFORM_CLICK_INDEX = 2, + WAVEFORM_SHORT_VIBRATION_EFFECT_INDEX = 3, + WAVEFORM_THUD_INDEX = 4, + WAVEFORM_SPIN_INDEX = 5, + WAVEFORM_QUICK_RISE_INDEX = 6, + WAVEFORM_SLOW_RISE_INDEX = 7, + WAVEFORM_QUICK_FALL_INDEX = 8, + WAVEFORM_LIGHT_TICK_INDEX = 9, + WAVEFORM_LOW_TICK_INDEX = 10, + WAVEFORM_RESERVED_MFG_1, + WAVEFORM_RESERVED_MFG_2, + WAVEFORM_RESERVED_MFG_3, + WAVEFORM_MAX_PHYSICAL_INDEX, + /* OWT waveform */ + WAVEFORM_COMPOSE = WAVEFORM_MAX_PHYSICAL_INDEX, + WAVEFORM_PWLE, + /* + * Refer to <linux/input.h>, the WAVEFORM_MAX_INDEX must not exceed 96. + * #define FF_GAIN 0x60 // 96 in decimal + * #define FF_MAX_EFFECTS FF_GAIN + */ + WAVEFORM_MAX_INDEX, + }; + + public: + StatsApi() { + mWaveformCounts = std::vector<int32_t>(WAVEFORM_MAX_INDEX, 0); + mDurationCounts = std::vector<int32_t>(DURATION_BUCKET_COUNT, 0); + mMinLatencies = std::vector<int32_t>(kEffectLatencyCount, 0); + mMaxLatencies = std::vector<int32_t>(kEffectLatencyCount, 0); + mLatencyTotals = std::vector<int32_t>(kEffectLatencyCount, 0); + mLatencyCounts = std::vector<int32_t>(kEffectLatencyCount, 0); + mErrorCounts = std::vector<int32_t>(kVibratorErrorCount, 0); + } + + bool logPrimitive(uint16_t effectIndex) override { + if (effectIndex >= WAVEFORM_MAX_PHYSICAL_INDEX || + effectIndex == WAVEFORM_LONG_VIBRATION_EFFECT_INDEX || + effectIndex == WAVEFORM_SHORT_VIBRATION_EFFECT_INDEX) { + ALOGE("Invalid waveform index for logging primitive: %d", effectIndex); + return false; + } + + { + std::scoped_lock<std::mutex> lock(mDataAccess); + mWaveformCounts[effectIndex]++; + } + + return true; + } + + bool logWaveform(uint16_t effectIndex, int32_t duration) override { + if (effectIndex != WAVEFORM_LONG_VIBRATION_EFFECT_INDEX && + effectIndex != WAVEFORM_SHORT_VIBRATION_EFFECT_INDEX + BASE_CONTINUOUS_EFFECT_OFFSET) { + ALOGE("Invalid waveform index for logging waveform: %d", effectIndex); + return false; + } else if (effectIndex == + WAVEFORM_SHORT_VIBRATION_EFFECT_INDEX + BASE_CONTINUOUS_EFFECT_OFFSET) { + effectIndex = WAVEFORM_SHORT_VIBRATION_EFFECT_INDEX; + } + + if (duration > MAX_TIME_MS || duration < 0) { + ALOGE("Invalid waveform duration for logging waveform: %d", duration); + return false; + } + + { + std::scoped_lock<std::mutex> lock(mDataAccess); + mWaveformCounts[effectIndex]++; + if (duration < DURATION_BUCKET_WIDTH * DURATION_50MS_BUCKET_COUNT) { + mDurationCounts[duration / DURATION_BUCKET_WIDTH]++; + } else { + mDurationCounts[DURATION_50MS_BUCKET_COUNT]++; + } + } + + return true; + } + + bool logError(uint16_t errorIndex) override { + if (errorIndex >= kVibratorErrorCount) { + ALOGE("Invalid index for logging error: %d", errorIndex); + return false; + } + + { + std::scoped_lock<std::mutex> lock(mDataAccess); + mErrorCounts[errorIndex]++; + } + + return true; + } + + bool logLatencyStart(uint16_t latencyIndex) override { + if (latencyIndex >= kEffectLatencyCount) { + ALOGE("Invalid index for measuring latency: %d", latencyIndex); + return false; + } + + mCurrentLatencyStart = std::chrono::steady_clock::now(); + mCurrentLatencyIndex = latencyIndex; + + return true; + } + + bool logLatencyEnd() override { + if (mCurrentLatencyIndex >= kEffectLatencyCount) { + return false; + } + + int32_t latency = (std::chrono::duration_cast<std::chrono::milliseconds>( + std::chrono::steady_clock::now() - mCurrentLatencyStart)) + .count(); + + { + std::scoped_lock<std::mutex> lock(mDataAccess); + if (latency < mMinLatencies[mCurrentLatencyIndex] || + mMinLatencies[mCurrentLatencyIndex] == 0) { + mMinLatencies[mCurrentLatencyIndex] = latency; + } + if (latency > mMaxLatencies[mCurrentLatencyIndex]) { + mMinLatencies[mCurrentLatencyIndex] = latency; + } + mLatencyTotals[mCurrentLatencyIndex] += latency; + mLatencyCounts[mCurrentLatencyIndex]++; + } + + mCurrentLatencyIndex = kEffectLatencyCount; + return true; + } + + void debug(int fd) override { (void)fd; } + + private: + uint16_t mCurrentLatencyIndex; + std::chrono::time_point<std::chrono::steady_clock> mCurrentLatencyStart; + std::vector<int32_t> mWaveformCounts; + std::vector<int32_t> mDurationCounts; + std::vector<int32_t> mMinLatencies; + std::vector<int32_t> mMaxLatencies; + std::vector<int32_t> mLatencyTotals; + std::vector<int32_t> mLatencyCounts; + std::vector<int32_t> mErrorCounts; + std::mutex mDataAccess; +}; + +} // namespace vibrator +} // namespace hardware +} // namespace android +} // namespace aidl diff --git a/vibrator/cs40l25/bench/benchmark.cpp b/vibrator/cs40l25/bench/benchmark.cpp index c43a2a2a..f447315c 100644 --- a/vibrator/cs40l25/bench/benchmark.cpp +++ b/vibrator/cs40l25/bench/benchmark.cpp @@ -18,6 +18,7 @@ #include <cutils/fs.h> #include "Hardware.h" +#include "Stats.h" #include "Vibrator.h" namespace aidl { @@ -75,8 +76,8 @@ class VibratorBench : public benchmark::Fixture { } } - mVibrator = ndk::SharedRefBase::make<Vibrator>(std::make_unique<HwApi>(), - std::make_unique<HwCal>()); + mVibrator = ndk::SharedRefBase::make<Vibrator>( + std::make_unique<HwApi>(), std::make_unique<HwCal>(), std::make_unique<StatsApi>()); } static void DefaultArgs(benchmark::internal::Benchmark *b) { b->Unit(benchmark::kMicrosecond); } diff --git a/vibrator/cs40l25/service.cpp b/vibrator/cs40l25/service.cpp index 977e0261..81e2edef 100644 --- a/vibrator/cs40l25/service.cpp +++ b/vibrator/cs40l25/service.cpp @@ -20,10 +20,12 @@ #include <log/log.h> #include "Hardware.h" +#include "Stats.h" #include "Vibrator.h" using ::aidl::android::hardware::vibrator::HwApi; using ::aidl::android::hardware::vibrator::HwCal; +using ::aidl::android::hardware::vibrator::StatsApi; using ::aidl::android::hardware::vibrator::Vibrator; using ::android::defaultServiceManager; using ::android::ProcessState; @@ -35,8 +37,8 @@ using ::android::String16; #endif int main() { - auto svc = ndk::SharedRefBase::make<Vibrator>(std::make_unique<HwApi>(), - std::make_unique<HwCal>()); + auto svc = ndk::SharedRefBase::make<Vibrator>( + std::make_unique<HwApi>(), std::make_unique<HwCal>(), std::make_unique<StatsApi>()); const auto svcName = std::string() + svc->descriptor + "/" + VIBRATOR_NAME; ProcessState::initWithDriver("/dev/vndbinder"); diff --git a/vibrator/cs40l25/tests/mocks.h b/vibrator/cs40l25/tests/mocks.h index efcef527..3cd46fc4 100644 --- a/vibrator/cs40l25/tests/mocks.h +++ b/vibrator/cs40l25/tests/mocks.h @@ -44,7 +44,7 @@ class MockApi : public ::aidl::android::hardware::vibrator::Vibrator::HwApi { MOCK_METHOD1(setGpioFallScale, bool(uint32_t value)); MOCK_METHOD1(setGpioRiseIndex, bool(uint32_t value)); MOCK_METHOD1(setGpioRiseScale, bool(uint32_t value)); - MOCK_METHOD1(pollVibeState, bool(bool value)); + MOCK_METHOD2(pollVibeState, bool(uint32_t value, int32_t timeoutMs)); MOCK_METHOD1(setClabEnable, bool(bool value)); MOCK_METHOD1(getAvailablePwleSegments, bool(uint32_t *value)); MOCK_METHOD0(hasPwle, bool()); @@ -75,6 +75,19 @@ class MockCal : public ::aidl::android::hardware::vibrator::Vibrator::HwCal { ~MockCal() override { destructor(); }; }; +class MockStats : public ::aidl::android::hardware::vibrator::Vibrator::StatsApi { + public: + MOCK_METHOD0(destructor, void()); + MOCK_METHOD1(logPrimitive, bool(uint16_t effectIndex)); + MOCK_METHOD2(logWaveform, bool(uint16_t effectIndex, int32_t duration)); + MOCK_METHOD1(logError, bool(uint16_t errorIndex)); + MOCK_METHOD1(logLatencyStart, bool(uint16_t latencyIndex)); + MOCK_METHOD0(logLatencyEnd, bool()); + MOCK_METHOD1(debug, void(int fd)); + + ~MockStats() override { destructor(); }; +}; + class MockVibratorCallback : public aidl::android::hardware::vibrator::BnVibratorCallback { public: MOCK_METHOD(ndk::ScopedAStatus, onComplete, ()); diff --git a/vibrator/cs40l25/tests/test-vibrator.cpp b/vibrator/cs40l25/tests/test-vibrator.cpp index 348322e7..16ac69d1 100644 --- a/vibrator/cs40l25/tests/test-vibrator.cpp +++ b/vibrator/cs40l25/tests/test-vibrator.cpp @@ -21,6 +21,7 @@ #include <future> +#include "Stats.h" #include "Vibrator.h" #include "mocks.h" #include "types.h" @@ -68,8 +69,8 @@ static EffectScale Scale(float intensity); static constexpr uint32_t CAL_VERSION = 1; static constexpr std::array<EffectLevel, 6> V_LEVELS{40, 50, 60, 70, 80, 90}; -static constexpr std::array<EffectDuration, 10> EFFECT_DURATIONS{0, 0, 15, 0, 50, - 100, 150, 200, 250, 8}; +static constexpr std::array<EffectDuration, 10> EFFECT_DURATIONS{0, 0, 11, 0, 300, + 132, 150, 500, 101, 5}; // Constants With Prescribed Values @@ -84,6 +85,10 @@ static constexpr EffectIndex QUEUE_INDEX{65534}; static const EffectScale ON_GLOBAL_SCALE{levelToScale(V_LEVELS[5])}; static const EffectIndex ON_EFFECT_INDEX{0}; +static constexpr uint32_t WAVEFORM_DOUBLE_CLICK_SILENCE_MS = 100; +static constexpr int8_t MAX_COLD_START_LATENCY_MS = 6; // I2C Transaction + DSP Return-From-Standby +static constexpr int8_t MAX_PAUSE_TIMING_ERROR_MS = 1; // ALERT Irq Handling +static constexpr auto POLLING_TIMEOUT = 20; static const std::map<EffectTuple, EffectScale> EFFECT_SCALE{ {{Effect::CLICK, EffectStrength::LIGHT}, Scale(0.7f * 0.5f)}, @@ -102,13 +107,16 @@ static const std::map<EffectTuple, EffectScale> EFFECT_SCALE{ static const std::map<EffectTuple, EffectQueue> EFFECT_QUEUE{ {{Effect::DOUBLE_CLICK, EffectStrength::LIGHT}, - Queue(QueueEffect{EFFECT_INDEX.at(Effect::CLICK), Level(0.7f * 0.5f)}, 100, + Queue(QueueEffect{EFFECT_INDEX.at(Effect::CLICK), Level(0.7f * 0.5f)}, + WAVEFORM_DOUBLE_CLICK_SILENCE_MS, QueueEffect{EFFECT_INDEX.at(Effect::CLICK), Level(1.0f * 0.5f)})}, {{Effect::DOUBLE_CLICK, EffectStrength::MEDIUM}, - Queue(QueueEffect{EFFECT_INDEX.at(Effect::CLICK), Level(0.7f * 0.7f)}, 100, + Queue(QueueEffect{EFFECT_INDEX.at(Effect::CLICK), Level(0.7f * 0.7f)}, + WAVEFORM_DOUBLE_CLICK_SILENCE_MS, QueueEffect{EFFECT_INDEX.at(Effect::CLICK), Level(1.0f * 0.7f)})}, {{Effect::DOUBLE_CLICK, EffectStrength::STRONG}, - Queue(QueueEffect{EFFECT_INDEX.at(Effect::CLICK), Level(0.7f * 1.0f)}, 100, + Queue(QueueEffect{EFFECT_INDEX.at(Effect::CLICK), Level(0.7f * 1.0f)}, + WAVEFORM_DOUBLE_CLICK_SILENCE_MS, QueueEffect{EFFECT_INDEX.at(Effect::CLICK), Level(1.0f * 1.0f)})}, }; @@ -149,20 +157,24 @@ class VibratorTest : public Test { void SetUp() override { std::unique_ptr<MockApi> mockapi; std::unique_ptr<MockCal> mockcal; + std::unique_ptr<MockStats> mockstats; - createMock(&mockapi, &mockcal); - createVibrator(std::move(mockapi), std::move(mockcal)); + createMock(&mockapi, &mockcal, &mockstats); + createVibrator(std::move(mockapi), std::move(mockcal), std::move(mockstats)); } void TearDown() override { deleteVibrator(); } protected: - void createMock(std::unique_ptr<MockApi> *mockapi, std::unique_ptr<MockCal> *mockcal) { + void createMock(std::unique_ptr<MockApi> *mockapi, std::unique_ptr<MockCal> *mockcal, + std::unique_ptr<MockStats> *mockstats) { *mockapi = std::make_unique<MockApi>(); *mockcal = std::make_unique<MockCal>(); + *mockstats = std::make_unique<MockStats>(); mMockApi = mockapi->get(); mMockCal = mockcal->get(); + mMockStats = mockstats->get(); ON_CALL(*mMockApi, destructor()).WillByDefault(Assign(&mMockApi, nullptr)); @@ -187,11 +199,12 @@ class VibratorTest : public Test { } void createVibrator(std::unique_ptr<MockApi> mockapi, std::unique_ptr<MockCal> mockcal, - bool relaxed = true) { + std::unique_ptr<MockStats> mockstats, bool relaxed = true) { if (relaxed) { relaxMock(true); } - mVibrator = ndk::SharedRefBase::make<Vibrator>(std::move(mockapi), std::move(mockcal)); + mVibrator = ndk::SharedRefBase::make<Vibrator>(std::move(mockapi), std::move(mockcal), + std::move(mockstats)); if (relaxed) { relaxMock(false); } @@ -224,6 +237,7 @@ class VibratorTest : public Test { Mock::VerifyAndClearExpectations(mMockApi); Mock::VerifyAndClearExpectations(mMockCal); + Mock::VerifyAndClearExpectations(mMockStats); EXPECT_CALL(*mMockApi, destructor()).Times(times); EXPECT_CALL(*mMockApi, setF0(_)).Times(times); @@ -254,11 +268,18 @@ class VibratorTest : public Test { EXPECT_CALL(*mMockCal, getQ(_)).Times(times); EXPECT_CALL(*mMockCal, getVolLevels(_)).Times(times); EXPECT_CALL(*mMockCal, debug(_)).Times(times); + + ON_CALL(*mMockStats, destructor()).WillByDefault(Assign(&mMockStats, nullptr)); + ON_CALL(*mMockStats, logPrimitive(_)).WillByDefault(Return(true)); + ON_CALL(*mMockStats, logWaveform(_, _)).WillByDefault(Return(true)); + ON_CALL(*mMockStats, logLatencyStart(_)).WillByDefault(Return(true)); + ON_CALL(*mMockStats, logLatencyEnd()).WillByDefault(Return(true)); } protected: MockApi *mMockApi; MockCal *mMockCal; + MockStats *mMockStats; std::shared_ptr<IVibrator> mVibrator; uint32_t mEffectIndex; }; @@ -266,6 +287,7 @@ class VibratorTest : public Test { TEST_F(VibratorTest, Constructor) { std::unique_ptr<MockApi> mockapi; std::unique_ptr<MockCal> mockcal; + std::unique_ptr<MockStats> mockstats; uint32_t f0Val = std::rand(); uint32_t redcVal = std::rand(); uint32_t qVal = std::rand(); @@ -275,10 +297,11 @@ TEST_F(VibratorTest, Constructor) { EXPECT_CALL(*mMockApi, destructor()).WillOnce(DoDefault()); EXPECT_CALL(*mMockCal, destructor()).WillOnce(DoDefault()); + EXPECT_CALL(*mMockStats, destructor()).WillOnce(DoDefault()); deleteVibrator(false); - createMock(&mockapi, &mockcal); + createMock(&mockapi, &mockcal, &mockstats); EXPECT_CALL(*mMockCal, getF0(_)) .InSequence(f0Seq) @@ -315,16 +338,21 @@ TEST_F(VibratorTest, Constructor) { EXPECT_CALL(*mMockApi, hasEffectScale()).WillRepeatedly(Return(true)); EXPECT_CALL(*mMockApi, hasAspEnable()).WillRepeatedly(Return(true)); - createVibrator(std::move(mockapi), std::move(mockcal), false); + createVibrator(std::move(mockapi), std::move(mockcal), std::move(mockstats), false); } TEST_F(VibratorTest, on) { Sequence s1, s2, s3; uint16_t duration = std::rand() + 1; + EXPECT_CALL(*mMockStats, logLatencyStart(kWaveformEffectLatency)) + .InSequence(s1, s2, s3) + .WillOnce(DoDefault()); + EXPECT_CALL(*mMockStats, logWaveform(_, _)).InSequence(s1).WillOnce(DoDefault()); EXPECT_CALL(*mMockApi, setGlobalScale(ON_GLOBAL_SCALE)).InSequence(s1).WillOnce(Return(true)); EXPECT_CALL(*mMockApi, setEffectIndex(ON_EFFECT_INDEX)).InSequence(s2).WillOnce(DoDefault()); EXPECT_CALL(*mMockApi, setDuration(Ge(duration))).InSequence(s3).WillOnce(Return(true)); + EXPECT_CALL(*mMockStats, logLatencyEnd()).InSequence(s1, s2, s3).WillOnce(DoDefault()); EXPECT_CALL(*mMockApi, setActivate(true)).InSequence(s1, s2, s3).WillOnce(Return(true)); EXPECT_TRUE(mVibrator->on(duration, nullptr).isOk()); @@ -468,16 +496,20 @@ TEST_P(EffectsTest, perform) { }; ExpectationSet eSetup; - Expectation eActivate, ePoll; + Expectation eActivate, ePollStop; + + eSetup += + EXPECT_CALL(*mMockStats, logLatencyStart(kPrebakedEffectLatency)).WillOnce(DoDefault()); if (scale != EFFECT_SCALE.end()) { EffectIndex index = EFFECT_INDEX.at(effect); - duration = EFFECT_DURATIONS[index]; + duration = EFFECT_DURATIONS[index] + MAX_COLD_START_LATENCY_MS; eSetup += EXPECT_CALL(*mMockApi, setEffectIndex(index)).WillOnce(DoDefault()); eSetup += EXPECT_CALL(*mMockApi, setEffectScale(scale->second)).WillOnce(Return(true)); } else if (queue != EFFECT_QUEUE.end()) { - duration = std::get<1>(queue->second); + duration = std::get<1>(queue->second) + MAX_COLD_START_LATENCY_MS * 2 + + MAX_PAUSE_TIMING_ERROR_MS; eSetup += EXPECT_CALL(*mMockApi, setEffectIndex(QUEUE_INDEX)).WillOnce(DoDefault()); eSetup += EXPECT_CALL(*mMockApi, setEffectQueue(std::get<0>(queue->second))) @@ -489,12 +521,14 @@ TEST_P(EffectsTest, perform) { if (duration) { eSetup += EXPECT_CALL(*mMockApi, setDuration(Ge(duration))).WillOnce(Return(true)); + eSetup += EXPECT_CALL(*mMockStats, logLatencyEnd()).WillOnce(DoDefault()); eActivate = EXPECT_CALL(*mMockApi, setActivate(true)).After(eSetup).WillOnce(Return(true)); - ePoll = EXPECT_CALL(*mMockApi, pollVibeState(false)) - .After(eActivate) - .WillOnce(Return(true)); - EXPECT_CALL(*mMockApi, setActivate(false)).After(ePoll).WillOnce(Return(true)); - EXPECT_CALL(*callback, onComplete()).After(ePoll).WillOnce(complete); + ePollStop = EXPECT_CALL(*mMockApi, pollVibeState(false, duration + POLLING_TIMEOUT)) + .After(eActivate) + .WillOnce(DoDefault()); + + EXPECT_CALL(*mMockApi, setActivate(false)).After(ePollStop).WillOnce(Return(true)); + EXPECT_CALL(*callback, onComplete()).After(ePollStop).WillOnce(complete); } int32_t lengthMs; @@ -589,8 +623,9 @@ TEST_P(ComposeTest, compose) { auto param = GetParam(); auto composite = param.composite; auto queue = std::get<0>(param.queue); + auto duration = std::get<1>(param.queue); ExpectationSet eSetup; - Expectation eActivate, ePoll; + Expectation eActivate, ePollStop; auto callback = ndk::SharedRefBase::make<MockVibratorCallback>(); std::promise<void> promise; std::future<void> future{promise.get_future()}; @@ -599,14 +634,22 @@ TEST_P(ComposeTest, compose) { return ndk::ScopedAStatus::ok(); }; + eSetup += EXPECT_CALL(*mMockStats, logLatencyStart(kCompositionEffectLatency)) + .WillOnce(DoDefault()); + for (auto &primitive : composite) { + eSetup += EXPECT_CALL(*mMockStats, logPrimitive(_)).After(eSetup).WillOnce(DoDefault()); + } eSetup += EXPECT_CALL(*mMockApi, setEffectIndex(QUEUE_INDEX)).WillOnce(DoDefault()); eSetup += EXPECT_CALL(*mMockApi, setEffectQueue(queue)).WillOnce(Return(true)); eSetup += EXPECT_CALL(*mMockApi, setEffectScale(0)).WillOnce(Return(true)); eSetup += EXPECT_CALL(*mMockApi, setDuration(UINT32_MAX)).WillOnce(Return(true)); + eSetup += EXPECT_CALL(*mMockStats, logLatencyEnd()).WillOnce(DoDefault()); eActivate = EXPECT_CALL(*mMockApi, setActivate(true)).After(eSetup).WillOnce(Return(true)); - ePoll = EXPECT_CALL(*mMockApi, pollVibeState(false)).After(eActivate).WillOnce(Return(true)); - EXPECT_CALL(*mMockApi, setActivate(false)).After(ePoll).WillOnce(Return(true)); - EXPECT_CALL(*callback, onComplete()).After(ePoll).WillOnce(complete); + ePollStop = EXPECT_CALL(*mMockApi, pollVibeState(false, duration + POLLING_TIMEOUT)) + .After(eActivate) + .WillOnce(Return(true)); + EXPECT_CALL(*mMockApi, setActivate(false)).After(ePollStop).WillOnce(Return(true)); + EXPECT_CALL(*callback, onComplete()).After(ePollStop).WillOnce(complete); EXPECT_EQ(EX_NONE, mVibrator->compose(composite, callback).getExceptionCode()); diff --git a/vibrator/cs40l26/Android.bp b/vibrator/cs40l26/Android.bp index 2399a944..6a2076a8 100644 --- a/vibrator/cs40l26/Android.bp +++ b/vibrator/cs40l26/Android.bp @@ -21,10 +21,7 @@ cc_defaults { name: "android.hardware.vibrator-defaults.cs40l26", cflags: [ "-DATRACE_TAG=(ATRACE_TAG_VIBRATOR | ATRACE_TAG_HAL)", - "-DLOG_TAG=\"android.hardware.vibrator-cs40l26\"", - ], - shared_libs: [ - "libbinder", + "-DLOG_TAG=\"Vibrator\"", ], } @@ -34,67 +31,89 @@ cc_defaults { "PixelVibratorBinaryDefaults", "android.hardware.vibrator-defaults.cs40l26", ], + include_dirs: [ + "external/tinyalsa/include", + ], + shared_libs: [ + "libcutils", + "libtinyalsa", + ], } cc_defaults { name: "VibratorHalCs40l26TestDefaults", defaults: [ "PixelVibratorTestDefaults", + "VibratorCapoDefaults", "android.hardware.vibrator-defaults.cs40l26", ], - shared_libs: ["android.hardware.vibrator-impl.cs40l26"], - include_dirs: [ - "external/tinyalsa/include", + static_libs: [ + "libtinyalsa", + "android.hardware.vibrator-impl.cs40l26", ], } -cc_library_shared { +cc_library { name: "android.hardware.vibrator-impl.cs40l26", - defaults: ["VibratorHalCs40l26BinaryDefaults"], - srcs: ["Vibrator.cpp"], - include_dirs: [ - "external/tinyalsa/include", + defaults: [ + "VibratorHalCs40l26BinaryDefaults", + "VibratorCapoDefaults", + "haptics_feature_defaults", ], - shared_libs: [ - "libcutils", - "libtinyalsa", + srcs: [ + "Vibrator.cpp", + ], + export_include_dirs: [ + ".", ], - export_include_dirs: ["."], vendor_available: true, visibility: [":__subpackages__"], } cc_binary { name: "android.hardware.vibrator-service.cs40l26", - defaults: ["VibratorHalCs40l26BinaryDefaults"], + defaults: [ + "VibratorHalCs40l26BinaryDefaults", + "VibratorCapoDefaults", + ], init_rc: ["android.hardware.vibrator-service.cs40l26.rc"], vintf_fragments: ["android.hardware.vibrator-service.cs40l26.xml"], srcs: ["service.cpp"], - include_dirs: [ - "external/tinyalsa/include" - ], shared_libs: [ "android.hardware.vibrator-impl.cs40l26", - "libcutils", - "libtinyalsa", + "PixelVibratorStats", ], proprietary: true, } cc_binary { name: "android.hardware.vibrator-service.cs40l26-dual", - defaults: ["VibratorHalCs40l26BinaryDefaults"], + defaults: [ + "VibratorHalCs40l26BinaryDefaults", + "VibratorCapoDefaults", + ], init_rc: ["android.hardware.vibrator-service.cs40l26-dual.rc"], vintf_fragments: ["android.hardware.vibrator-service.cs40l26-dual.xml"], srcs: ["service.cpp"], - include_dirs: [ - "external/tinyalsa/include" - ], shared_libs: [ "android.hardware.vibrator-impl.cs40l26", - "libcutils", - "libtinyalsa", + "PixelVibratorStats", ], cflags: ["-DVIBRATOR_NAME=\"dual\""], proprietary: true, } + +filegroup { + name: "haptics_srcs", + srcs: ["service.cpp", "Vibrator.cpp"], +} + +filegroup { + name: "android.hardware.vibrator-service.cs40l26.xml", + srcs: ["android.hardware.vibrator-service.cs40l26.xml"], +} + +filegroup { + name: "android.hardware.vibrator-service.cs40l26.rc", + srcs: ["android.hardware.vibrator-service.cs40l26.rc"], +} diff --git a/vibrator/cs40l26/Hardware.h b/vibrator/cs40l26/Hardware.h index f0d70388..d5230fee 100644 --- a/vibrator/cs40l26/Hardware.h +++ b/vibrator/cs40l26/Hardware.h @@ -15,9 +15,52 @@ */ #pragma once +#include <glob.h> + +#include <algorithm> + #include "HardwareBase.h" #include "Vibrator.h" +#define PROC_SND_PCM "/proc/asound/pcm" +#define HAPTIC_PCM_DEVICE_SYMBOL "haptic nohost playback" + +static struct pcm_config haptic_nohost_config = { + .channels = 1, + .rate = 48000, + .period_size = 80, + .period_count = 2, + .format = PCM_FORMAT_S16_LE, +}; + +enum WaveformIndex : uint16_t { + /* Physical waveform */ + WAVEFORM_LONG_VIBRATION_EFFECT_INDEX = 0, + WAVEFORM_RESERVED_INDEX_1 = 1, + WAVEFORM_CLICK_INDEX = 2, + WAVEFORM_SHORT_VIBRATION_EFFECT_INDEX = 3, + WAVEFORM_THUD_INDEX = 4, + WAVEFORM_SPIN_INDEX = 5, + WAVEFORM_QUICK_RISE_INDEX = 6, + WAVEFORM_SLOW_RISE_INDEX = 7, + WAVEFORM_QUICK_FALL_INDEX = 8, + WAVEFORM_LIGHT_TICK_INDEX = 9, + WAVEFORM_LOW_TICK_INDEX = 10, + WAVEFORM_RESERVED_MFG_1, + WAVEFORM_RESERVED_MFG_2, + WAVEFORM_RESERVED_MFG_3, + WAVEFORM_MAX_PHYSICAL_INDEX, + /* OWT waveform */ + WAVEFORM_COMPOSE = WAVEFORM_MAX_PHYSICAL_INDEX, + WAVEFORM_PWLE, + /* + * Refer to <linux/input.h>, the WAVEFORM_MAX_INDEX must not exceed 96. + * #define FF_GAIN 0x60 // 96 in decimal + * #define FF_MAX_EFFECTS FF_GAIN + */ + WAVEFORM_MAX_INDEX, +}; + namespace aidl { namespace android { namespace hardware { @@ -26,6 +69,7 @@ namespace vibrator { class HwApi : public Vibrator::HwApi, private HwApiBase { public: HwApi() { + HwApi::initFF(); open("calibration/f0_stored", &mF0); open("default/f0_offset", &mF0Offset); open("calibration/redc_stored", &mRedc); @@ -51,6 +95,264 @@ class HwApi : public Vibrator::HwApi, private HwApiBase { bool setF0CompEnable(bool value) override { return set(value, &mF0CompEnable); } bool setRedcCompEnable(bool value) override { return set(value, &mRedcCompEnable); } bool setMinOnOffInterval(uint32_t value) override { return set(value, &mMinOnOffInterval); } + uint32_t getContextScale() override { + return utils::getProperty("persist.vendor.vibrator.hal.context.scale", 100); + } + bool getContextEnable() override { + return utils::getProperty("persist.vendor.vibrator.hal.context.enable", false); + } + uint32_t getContextSettlingTime() override { + return utils::getProperty("persist.vendor.vibrator.hal.context.settlingtime", 3000); + } + uint32_t getContextCooldownTime() override { + return utils::getProperty("persist.vendor.vibrator.hal.context.cooldowntime", 1000); + } + bool getContextFadeEnable() override { + return utils::getProperty("persist.vendor.vibrator.hal.context.fade", false); + } + + // TODO(b/234338136): Need to add the force feedback HW API test cases + bool initFF() override { + ATRACE_NAME(__func__); + const std::string INPUT_EVENT_NAME = std::getenv("INPUT_EVENT_NAME") ?: ""; + if (INPUT_EVENT_NAME.find("cs40l26") == std::string::npos) { + ALOGE("Invalid input name: %s", INPUT_EVENT_NAME.c_str()); + return false; + } + + glob_t g = {}; + const std::string INPUT_EVENT_PATH = "/dev/input/event*"; + int fd = -1, ret; + uint32_t val = 0; + char str[256] = {0x00}; + // Scan /dev/input/event* to get the correct input device path for FF effects manipulation. + // Then constructs the /sys/class/input/event*/../../../ for driver attributes accessing + // across different platforms and different kernels. + for (uint8_t retry = 1; retry < 11 && !mInputFd.ok(); retry++) { + ret = glob(INPUT_EVENT_PATH.c_str(), 0, nullptr, &g); + if (ret) { + ALOGE("Failed to get input event paths (%d): %s", errno, strerror(errno)); + } else { + for (size_t i = 0; i < g.gl_pathc; i++) { + fd = TEMP_FAILURE_RETRY(::open(g.gl_pathv[i], O_RDWR)); + if (fd < 0) { + continue; + } + // Determine the input device path: + // 1. Check if EV_FF is flagged in event bits. + // 2. Match device name(s) with this CS40L26 HAL instance. + if (ioctl(fd, EVIOCGBIT(0, sizeof(val)), &val) > 0 && (val & (1 << EV_FF)) && + ioctl(fd, EVIOCGNAME(sizeof(str)), &str) > 0 && + strcmp(str, INPUT_EVENT_NAME.c_str()) == 0) { + mInputFd.reset(fd); // mInputFd.ok() becomes true. + ALOGI("Control %s through %s", INPUT_EVENT_NAME.c_str(), g.gl_pathv[i]); + + // Construct the sysfs device path. + std::string path = g.gl_pathv[i]; + path = "/sys/class/input/" + + path.substr(path.find("event"), std::string::npos) + "/../../../"; + updatePathPrefix(path); + break; + } + close(fd); + memset(str, 0x00, sizeof(str)); + val = 0; + } + } + + if (!mInputFd.ok()) { + sleep(1); + ALOGW("Retry #%d to search in %zu input devices...", retry, g.gl_pathc); + } + } + globfree(&g); + + if (!mInputFd.ok()) { + ALOGE("Failed to get an input event with name %s", INPUT_EVENT_NAME.c_str()); + return false; + } + + return true; + } + bool setFFGain(uint16_t value) override { + ATRACE_NAME(StringPrintf("%s %d%%", __func__, value).c_str()); + struct input_event gain = { + .type = EV_FF, + .code = FF_GAIN, + .value = value, + }; + if (value > 100) { + ALOGE("Invalid gain"); + return false; + } + if (write(mInputFd, (const void *)&gain, sizeof(gain)) != sizeof(gain)) { + return false; + } + return true; + } + bool setFFEffect(struct ff_effect *effect, uint16_t timeoutMs) override { + ATRACE_NAME(StringPrintf("%s %dms", __func__, timeoutMs).c_str()); + if (effect == nullptr) { + ALOGE("Invalid ff_effect"); + return false; + } + if (((*effect).replay.length != timeoutMs) || (ioctl(mInputFd, EVIOCSFF, effect) < 0)) { + ALOGE("setFFEffect fail"); + return false; + } else { + return true; + } + } + bool setFFPlay(int8_t index, bool value) override { + ATRACE_NAME(StringPrintf("%s index:%d %s", __func__, index, value ? "on" : "off").c_str()); + struct input_event play = { + .type = EV_FF, + .code = static_cast<uint16_t>(index), + .value = value, + }; + if (write(mInputFd, (const void *)&play, sizeof(play)) != sizeof(play)) { + return false; + } else { + return true; + } + } + bool getHapticAlsaDevice(int *card, int *device) override { + ATRACE_NAME(__func__); + std::string line; + std::ifstream myfile(PROC_SND_PCM); + if (myfile.is_open()) { + while (getline(myfile, line)) { + if (line.find(HAPTIC_PCM_DEVICE_SYMBOL) != std::string::npos) { + std::stringstream ss(line); + std::string currentToken; + std::getline(ss, currentToken, ':'); + sscanf(currentToken.c_str(), "%d-%d", card, device); + return true; + } + } + myfile.close(); + } else { + ALOGE("Failed to read file: %s", PROC_SND_PCM); + } + return false; + } + bool setHapticPcmAmp(struct pcm **haptic_pcm, bool enable, int card, int device) override { + ATRACE_NAME(StringPrintf("%s %s", __func__, enable ? "enable" : "disable").c_str()); + int ret = 0; + + if (enable) { + *haptic_pcm = pcm_open(card, device, PCM_OUT, &haptic_nohost_config); + if (!pcm_is_ready(*haptic_pcm)) { + ALOGE("cannot open pcm_out driver: %s", pcm_get_error(*haptic_pcm)); + goto fail; + } + + ret = pcm_prepare(*haptic_pcm); + if (ret < 0) { + ALOGE("cannot prepare haptic_pcm: %s", pcm_get_error(*haptic_pcm)); + goto fail; + } + + ret = pcm_start(*haptic_pcm); + if (ret < 0) { + ALOGE("cannot start haptic_pcm: %s", pcm_get_error(*haptic_pcm)); + goto fail; + } + + return true; + } else { + if (*haptic_pcm) { + pcm_close(*haptic_pcm); + *haptic_pcm = NULL; + } + return true; + } + + fail: + pcm_close(*haptic_pcm); + *haptic_pcm = NULL; + return false; + } + bool uploadOwtEffect(const uint8_t *owtData, const uint32_t numBytes, struct ff_effect *effect, + uint32_t *outEffectIndex, int *status) override { + ATRACE_NAME(__func__); + if (owtData == nullptr || effect == nullptr || outEffectIndex == nullptr) { + ALOGE("Invalid argument owtData, ff_effect or outEffectIndex"); + *status = EX_NULL_POINTER; + return false; + } + if (status == nullptr) { + ALOGE("Invalid argument status"); + return false; + } + + (*effect).u.periodic.custom_len = numBytes / sizeof(uint16_t); + memcpy((*effect).u.periodic.custom_data, owtData, numBytes); + + if ((*effect).id != -1) { + ALOGE("(*effect).id != -1"); + } + + /* Create a new OWT waveform to update the PWLE or composite effect. */ + (*effect).id = -1; + if (ioctl(mInputFd, EVIOCSFF, effect) < 0) { + ALOGE("Failed to upload effect %d (%d): %s", *outEffectIndex, errno, strerror(errno)); + *status = EX_ILLEGAL_STATE; + return false; + } + + if ((*effect).id >= FF_MAX_EFFECTS || (*effect).id < 0) { + ALOGE("Invalid waveform index after upload OWT effect: %d", (*effect).id); + *status = EX_ILLEGAL_ARGUMENT; + return false; + } + *outEffectIndex = (*effect).id; + *status = 0; + return true; + } + bool eraseOwtEffect(int8_t effectIndex, std::vector<ff_effect> *effect) override { + ATRACE_NAME(__func__); + uint32_t effectCountBefore, effectCountAfter, i, successFlush = 0; + + if (effectIndex < WAVEFORM_MAX_PHYSICAL_INDEX) { + ALOGE("Invalid waveform index for OWT erase: %d", effectIndex); + return false; + } + if (effect == nullptr || (*effect).empty()) { + ALOGE("Invalid argument effect"); + return false; + } + + if (effectIndex < WAVEFORM_MAX_INDEX) { + /* Normal situation. Only erase the effect which we just played. */ + if (ioctl(mInputFd, EVIOCRMFF, effectIndex) < 0) { + ALOGE("Failed to erase effect %d (%d): %s", effectIndex, errno, strerror(errno)); + } + for (i = WAVEFORM_MAX_PHYSICAL_INDEX; i < WAVEFORM_MAX_INDEX; i++) { + if ((*effect)[i].id == effectIndex) { + (*effect)[i].id = -1; + break; + } + } + } else { + /* Flush all non-prestored effects of ff-core and driver. */ + getEffectCount(&effectCountBefore); + for (i = WAVEFORM_MAX_PHYSICAL_INDEX; i < FF_MAX_EFFECTS; i++) { + if (ioctl(mInputFd, EVIOCRMFF, i) >= 0) { + successFlush++; + } + } + getEffectCount(&effectCountAfter); + ALOGW("Flushed effects: ff: %d; driver: %d -> %d; success: %d", effectIndex, + effectCountBefore, effectCountAfter, successFlush); + /* Reset all OWT effect index of HAL. */ + for (i = WAVEFORM_MAX_PHYSICAL_INDEX; i < WAVEFORM_MAX_INDEX; i++) { + (*effect)[i].id = -1; + } + } + return true; + } + void debug(int fd) override { HwApiBase::debug(fd); } private: @@ -64,6 +366,7 @@ class HwApi : public Vibrator::HwApi, private HwApiBase { std::ofstream mF0CompEnable; std::ofstream mRedcCompEnable; std::ofstream mMinOnOffInterval; + ::android::base::unique_fd mInputFd; }; class HwCal : public Vibrator::HwCal, private HwCalBase { @@ -78,8 +381,10 @@ class HwCal : public Vibrator::HwCal, private HwCalBase { static constexpr uint32_t VERSION_DEFAULT = 2; static constexpr int32_t DEFAULT_FREQUENCY_SHIFT = 0; + static constexpr float DEFAULT_DEVICE_MASS = 0.21; + static constexpr float DEFAULT_LOC_COEFF = 2.5; static constexpr std::array<uint32_t, 2> V_TICK_DEFAULT = {1, 100}; - static constexpr std::array<uint32_t, 2> V_CTICK_DEFAULT = {1, 100}; + static constexpr std::array<uint32_t, 2> V_CLICK_DEFAULT = {1, 100}; static constexpr std::array<uint32_t, 2> V_LONG_DEFAULT = {1, 100}; public: @@ -95,6 +400,12 @@ class HwCal : public Vibrator::HwCal, private HwCalBase { bool getLongFrequencyShift(int32_t *value) override { return getProperty("long.frequency.shift", value, DEFAULT_FREQUENCY_SHIFT); } + bool getDeviceMass(float *value) override { + return getProperty("device.mass", value, DEFAULT_DEVICE_MASS); + } + bool getLocCoeff(float *value) override { + return getProperty("loc.coeff", value, DEFAULT_LOC_COEFF); + } bool getF0(std::string *value) override { return getPersist(F0_CONFIG, value); } bool getRedc(std::string *value) override { return getPersist(REDC_CONFIG, value); } bool getQ(std::string *value) override { return getPersist(Q_CONFIG, value); } @@ -109,7 +420,7 @@ class HwCal : public Vibrator::HwCal, private HwCalBase { if (getPersist(CLICK_VOLTAGES_CONFIG, value)) { return true; } - *value = V_CTICK_DEFAULT; + *value = V_CLICK_DEFAULT; return true; } bool getLongVolLevels(std::array<uint32_t, 2> *value) override { @@ -127,6 +438,16 @@ class HwCal : public Vibrator::HwCal, private HwCalBase { bool getSupportedPrimitives(uint32_t *value) override { return getProperty("supported_primitives", value, (uint32_t)0); } + bool isF0CompEnabled() override { + bool value; + getProperty("f0.comp.enabled", &value, true); + return value; + } + bool isRedcCompEnabled() override { + bool value; + getProperty("redc.comp.enabled", &value, true); + return value; + } void debug(int fd) override { HwCalBase::debug(fd); } }; diff --git a/vibrator/cs40l26/Stats.h b/vibrator/cs40l26/Stats.h new file mode 100644 index 00000000..39480061 --- /dev/null +++ b/vibrator/cs40l26/Stats.h @@ -0,0 +1,260 @@ +/* + * 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. + */ +#pragma once + +#include <log/log.h> +#include <utils/Trace.h> + +#include <algorithm> +#include <chrono> +#include <mutex> + +#include "Hardware.h" +#include "StatsBase.h" +#include "Vibrator.h" + +constexpr int32_t DURATION_BUCKET_WIDTH = 50; +constexpr int32_t DURATION_50MS_BUCKET_COUNT = 20; +constexpr int32_t DURATION_BUCKET_COUNT = DURATION_50MS_BUCKET_COUNT + 1; +constexpr uint32_t MAX_TIME_MS = UINT16_MAX; + +#ifndef ARRAY_SIZE +#define ARRAY_SIZE(x) (sizeof((x)) / sizeof((x)[0])) +#endif + +#ifdef HAPTIC_TRACE +static const char *kWaveformLookup[] = {"WAVEFORM_LONG_VIBRATION_EFFECT", + "WAVEFORM_RESERVED_1", + "WAVEFORM_CLICK", + "WAVEFORM_SHORT_VIBRATION_EFFECT", + "WAVEFORM_THUD", + "WAVEFORM_SPIN", + "WAVEFORM_QUICK_RISE", + "WAVEFORM_SLOW_RISE", + "WAVEFORM_QUICK_FALL", + "WAVEFORM_LIGHT_TICK", + "WAVEFORM_LOW_TICK", + "WAVEFORM_RESERVED_MFG_1", + "WAVEFORM_RESERVED_MFG_2", + "WAVEFORM_RESERVED_MFG_3", + "WAVEFORM_COMPOSE", + "WAVEFORM_PWLE", + "INVALID"}; +static const char *kLatencyLookup[] = {"kWaveformEffectLatency", "kPrebakedEffectLatency", + "kCompositionEffectLatency", "kPwleEffectLatency", + "INVALID"}; +static const char *kErrorLookup[] = {"kInitError", + "kHwApiError", + "kHwCalError", + "kComposeFailError", + "kAlsaFailError", + "kAsyncFailError", + "kBadTimeoutError", + "kBadAmplitudeError", + "kBadEffectError", + "kBadEffectStrengthError", + "kBadPrimitiveError", + "kBadCompositeError", + "kPwleConstructionFailError", + "kUnsupportedOpError", + "INVALID"}; + +const char *waveformToString(uint16_t index) { + return kWaveformLookup[(index < ARRAY_SIZE(kWaveformLookup)) ? index + : ARRAY_SIZE(kWaveformLookup) - 1]; +} + +const char *latencyToString(uint16_t index) { + return kLatencyLookup[(index < ARRAY_SIZE(kLatencyLookup)) ? index + : ARRAY_SIZE(kLatencyLookup) - 1]; +} + +const char *errorToString(uint16_t index) { + return kErrorLookup[(index < ARRAY_SIZE(kErrorLookup)) ? index : ARRAY_SIZE(kErrorLookup) - 1]; +} + +#define STATS_TRACE(...) \ + ATRACE_NAME(__func__); \ + ALOGD(__VA_ARGS__) +#else +#define STATS_TRACE(...) ATRACE_NAME(__func__) +#define waveformToString(x) +#define latencyToString(x) +#define errorToString(x) +#endif + +namespace aidl { +namespace android { +namespace hardware { +namespace vibrator { + +enum EffectLatency : uint16_t { + kWaveformEffectLatency = 0, + kPrebakedEffectLatency, + kCompositionEffectLatency, + kPwleEffectLatency, + + kEffectLatencyCount +}; + +enum VibratorError : uint16_t { + kInitError = 0, + kHwApiError, + kHwCalError, + kComposeFailError, + kAlsaFailError, + kAsyncFailError, + kBadTimeoutError, + kBadAmplitudeError, + kBadEffectError, + kBadEffectStrengthError, + kBadPrimitiveError, + kBadCompositeError, + kPwleConstructionFailError, + kUnsupportedOpError, + + kVibratorErrorCount +}; + +class StatsApi : public Vibrator::StatsApi, private StatsBase { + public: + StatsApi() + : StatsBase(std::string(std::getenv("STATS_INSTANCE"))), + mCurrentLatencyIndex(kEffectLatencyCount) { + mWaveformCounts = std::vector<int32_t>(WAVEFORM_MAX_INDEX, 0); + mDurationCounts = std::vector<int32_t>(DURATION_BUCKET_COUNT, 0); + mMinLatencies = std::vector<int32_t>(kEffectLatencyCount, 0); + mMaxLatencies = std::vector<int32_t>(kEffectLatencyCount, 0); + mLatencyTotals = std::vector<int32_t>(kEffectLatencyCount, 0); + mLatencyCounts = std::vector<int32_t>(kEffectLatencyCount, 0); + mErrorCounts = std::vector<int32_t>(kVibratorErrorCount, 0); + } + + bool logPrimitive(uint16_t effectIndex) override { + STATS_TRACE("logPrimitive(effectIndex: %s)", waveformToString(effectIndex)); + + if (effectIndex >= WAVEFORM_MAX_PHYSICAL_INDEX || + effectIndex == WAVEFORM_LONG_VIBRATION_EFFECT_INDEX || + effectIndex == WAVEFORM_SHORT_VIBRATION_EFFECT_INDEX) { + ALOGE("Invalid waveform index for logging primitive: %d", effectIndex); + return false; + } + + { + std::scoped_lock<std::mutex> lock(mDataAccess); + mWaveformCounts[effectIndex]++; + } + + return true; + } + + bool logWaveform(uint16_t effectIndex, int32_t duration) override { + STATS_TRACE("logWaveform(effectIndex: %s, duration: %d)", waveformToString(effectIndex), + duration); + + if (effectIndex != WAVEFORM_LONG_VIBRATION_EFFECT_INDEX && + effectIndex != WAVEFORM_SHORT_VIBRATION_EFFECT_INDEX) { + ALOGE("Invalid waveform index for logging waveform: %d", effectIndex); + return false; + } + + if (duration > MAX_TIME_MS || duration < 0) { + ALOGE("Invalid waveform duration for logging waveform: %d", duration); + return false; + } + + { + std::scoped_lock<std::mutex> lock(mDataAccess); + mWaveformCounts[effectIndex]++; + if (duration < DURATION_BUCKET_WIDTH * DURATION_50MS_BUCKET_COUNT) { + mDurationCounts[duration / DURATION_BUCKET_WIDTH]++; + } else { + mDurationCounts[DURATION_50MS_BUCKET_COUNT]++; + } + } + + return true; + } + + bool logError(uint16_t errorIndex) override { + STATS_TRACE("logError(errorIndex: %s)", errorToString(errorIndex)); + + if (errorIndex >= kVibratorErrorCount) { + ALOGE("Invalid index for logging error: %d", errorIndex); + return false; + } + + { + std::scoped_lock<std::mutex> lock(mDataAccess); + mErrorCounts[errorIndex]++; + } + + return true; + } + + bool logLatencyStart(uint16_t latencyIndex) override { + STATS_TRACE("logLatencyStart(latencyIndex: %s)", latencyToString(latencyIndex)); + + if (latencyIndex >= kEffectLatencyCount) { + ALOGE("Invalid index for measuring latency: %d", latencyIndex); + return false; + } + + mCurrentLatencyStart = std::chrono::steady_clock::now(); + mCurrentLatencyIndex = latencyIndex; + + return true; + } + + bool logLatencyEnd() override { + STATS_TRACE("logLatencyEnd()"); + + if (mCurrentLatencyIndex >= kEffectLatencyCount) { + return false; + } + + int32_t latency = (std::chrono::duration_cast<std::chrono::milliseconds>( + std::chrono::steady_clock::now() - mCurrentLatencyStart)) + .count(); + + { + std::scoped_lock<std::mutex> lock(mDataAccess); + if (latency < mMinLatencies[mCurrentLatencyIndex] || + mMinLatencies[mCurrentLatencyIndex] == 0) { + mMinLatencies[mCurrentLatencyIndex] = latency; + } + if (latency > mMaxLatencies[mCurrentLatencyIndex]) { + mMaxLatencies[mCurrentLatencyIndex] = latency; + } + mLatencyTotals[mCurrentLatencyIndex] += latency; + mLatencyCounts[mCurrentLatencyIndex]++; + } + + mCurrentLatencyIndex = kEffectLatencyCount; + return true; + } + + void debug(int fd) override { StatsBase::debug(fd); } + + private: + uint16_t mCurrentLatencyIndex; + std::chrono::time_point<std::chrono::steady_clock> mCurrentLatencyStart; +}; + +} // namespace vibrator +} // namespace hardware +} // namespace android +} // namespace aidl diff --git a/vibrator/cs40l26/TEST_MAPPING b/vibrator/cs40l26/TEST_MAPPING new file mode 100644 index 00000000..1d8ff7ac --- /dev/null +++ b/vibrator/cs40l26/TEST_MAPPING @@ -0,0 +1,10 @@ +{ + "presubmit": [ + { + "name": "VibratorHalCs40l26TestSuite", + "keywords": [ + "nextgen" + ] + } + ] +} diff --git a/vibrator/cs40l26/Vibrator.cpp b/vibrator/cs40l26/Vibrator.cpp index 587f0fe4..ccc2fa68 100644 --- a/vibrator/cs40l26/Vibrator.cpp +++ b/vibrator/cs40l26/Vibrator.cpp @@ -16,32 +16,38 @@ #include "Vibrator.h" -#include <glob.h> +#include <android-base/properties.h> #include <hardware/hardware.h> #include <hardware/vibrator.h> -#include <linux/input.h> #include <log/log.h> -#include <stdio.h> #include <utils/Trace.h> #include <cinttypes> #include <cmath> #include <fstream> #include <iostream> +#include <map> +#include <memory> +#include <optional> #include <sstream> +#include "Stats.h" + #ifndef ARRAY_SIZE #define ARRAY_SIZE(x) (sizeof((x)) / sizeof((x)[0])) #endif -#define PROC_SND_PCM "/proc/asound/pcm" -#define HAPTIC_PCM_DEVICE_SYMBOL "haptic nohost playback" - namespace aidl { namespace android { namespace hardware { namespace vibrator { -static constexpr uint8_t FF_CUSTOM_DATA_LEN = 2; + +#ifdef HAPTIC_TRACE +#define HAPTICS_TRACE(...) ALOGD(__VA_ARGS__) +#else +#define HAPTICS_TRACE(...) +#endif + static constexpr uint16_t FF_CUSTOM_DATA_LEN_MAX_COMP = 2044; // (COMPOSE_SIZE_MAX + 1) * 8 + 4 static constexpr uint16_t FF_CUSTOM_DATA_LEN_MAX_PWLE = 2302; @@ -53,7 +59,7 @@ static constexpr uint8_t VOLTAGE_SCALE_MAX = 100; static constexpr int8_t MAX_COLD_START_LATENCY_MS = 6; // I2C Transaction + DSP Return-From-Standby static constexpr uint32_t MIN_ON_OFF_INTERVAL_US = 8500; // SVC initialization time -static constexpr int8_t MAX_PAUSE_TIMING_ERROR_MS = 1; // ALERT Irq Handling +static constexpr int8_t MAX_PAUSE_TIMING_ERROR_MS = 1; // ALERT Irq Handling static constexpr uint32_t MAX_TIME_MS = UINT16_MAX; static constexpr auto ASYNC_COMPLETION_TIMEOUT = std::chrono::milliseconds(100); @@ -70,6 +76,14 @@ static constexpr int32_t COMPOSE_PWLE_SIZE_MAX_DEFAULT = 127; // See the LRA Calibration Support documentation for more details. static constexpr int32_t Q14_BIT_SHIFT = 14; +// Measured ReDC. The LRA series resistance (ReDC), expressed as follows +// redc(ohms) = redc_measured / 2^Q15_BIT_SHIFT. +// This value represents the unit-specific ReDC input to the click compensation +// algorithm. It can be overwritten at a later time by writing to the redc_stored +// sysfs control. +// See the LRA Calibration Support documentation for more details. +static constexpr int32_t Q15_BIT_SHIFT = 15; + // Measured Q factor, q_measured, is represented by Q8.16 fixed // point format on cs40l26 devices. The expression to calculate q is: // q = q_measured / 2^Q16_BIT_SHIFT @@ -85,38 +99,15 @@ static constexpr uint8_t PWLE_AMP_REG_BIT = 0x2; static constexpr float PWLE_LEVEL_MIN = 0.0; static constexpr float PWLE_LEVEL_MAX = 1.0; -static constexpr float CS40L26_PWLE_LEVEL_MIX = -1.0; +static constexpr float CS40L26_PWLE_LEVEL_MIN = -1.0; static constexpr float CS40L26_PWLE_LEVEL_MAX = 0.9995118; static constexpr float PWLE_FREQUENCY_RESOLUTION_HZ = 1.00; -static constexpr float PWLE_FREQUENCY_MIN_HZ = 1.00; -static constexpr float PWLE_FREQUENCY_MAX_HZ = 1000.00; +static constexpr float PWLE_FREQUENCY_MIN_HZ = 30.0f; +static constexpr float RESONANT_FREQUENCY_DEFAULT = 145.0f; +static constexpr float PWLE_FREQUENCY_MAX_HZ = 300.0f; static constexpr float PWLE_BW_MAP_SIZE = 1 + ((PWLE_FREQUENCY_MAX_HZ - PWLE_FREQUENCY_MIN_HZ) / PWLE_FREQUENCY_RESOLUTION_HZ); -static struct pcm_config haptic_nohost_config = { - .channels = 1, - .rate = 48000, - .period_size = 80, - .period_count = 2, - .format = PCM_FORMAT_S16_LE, -}; - -static uint16_t amplitudeToScale(float amplitude, float maximum) { - float ratio = 100; /* Unit: % */ - if (maximum != 0) - ratio = amplitude / maximum * 100; - - if (maximum == 0 || ratio > 100) - ratio = 100; - - return std::round(ratio); -} - -enum class AlwaysOnId : uint32_t { - GPIO_RISE, - GPIO_FALL, -}; - enum WaveformBankID : uint8_t { RAM_WVFRM_BANK, ROM_WVFRM_BANK, @@ -145,8 +136,8 @@ enum WaveformIndex : uint16_t { WAVEFORM_PWLE, /* * Refer to <linux/input.h>, the WAVEFORM_MAX_INDEX must not exceed 96. - * #define FF_GAIN 0x60 // 96 in decimal - * #define FF_MAX_EFFECTS FF_GAIN + * #define FF_GAIN 0x60 // 96 in decimal + * #define FF_MAX_EFFECTS FF_GAIN */ WAVEFORM_MAX_INDEX, }; @@ -160,201 +151,323 @@ enum vibe_state { VIBE_STATE_ASP, }; -static int min(int x, int y) { - return x < y ? x : y; -} +std::mutex mActiveId_mutex; // protects mActiveId + +class DspMemChunk { + private: + std::unique_ptr<uint8_t[]> head; + size_t bytes = 0; + uint8_t waveformType; + uint8_t *_current; + const uint8_t *_max; + uint32_t _cache = 0; + int _cachebits = 0; + + bool isEnd() const { return _current == _max; } + int min(int x, int y) { return x < y ? x : y; } + + int write(int nbits, uint32_t val) { + HAPTICS_TRACE(" DspMemChunk::write(nbits:%d, val:%u)", nbits, val); + int nwrite, i; + + nwrite = min(24 - _cachebits, nbits); + _cache <<= nwrite; + _cache |= val >> (nbits - nwrite); + _cachebits += nwrite; + nbits -= nwrite; + + if (_cachebits == 24) { + if (isEnd()) + return -ENOSPC; + + _cache &= 0xFFFFFF; + for (i = 0; i < sizeof(_cache); i++, _cache <<= 8) + *_current++ = (_cache & 0xFF000000) >> 24; + + bytes += sizeof(_cache); + _cachebits = 0; + } -static int floatToUint16(float input, uint16_t *output, float scale, float min, float max) { - if (input < min || input > max) - return -ERANGE; + if (nbits) + return write(nbits, val); - *output = roundf(input * scale); - return 0; -} + return 0; + } -struct dspmem_chunk { - uint8_t *head; - uint8_t *current; - uint8_t *max; - int bytes; + int fToU16(float input, uint16_t *output, float scale, float min, float max) { + HAPTICS_TRACE(" DspMemChunk::fToU16(input:%f, output, scale:%f, min:%f, max:%f", input, + scale, min, max); + if (input < min || input > max) + return -ERANGE; - uint32_t cache; - int cachebits; -}; + *output = roundf(input * scale); + return 0; + } -static dspmem_chunk *dspmem_chunk_create(void *data, int size) { - auto ch = new dspmem_chunk{ - .head = reinterpret_cast<uint8_t *>(data), - .current = reinterpret_cast<uint8_t *>(data), - .max = reinterpret_cast<uint8_t *>(data) + size, - }; + void constructPwleSegment(uint16_t delay, uint16_t amplitude, uint16_t frequency, uint8_t flags, + uint32_t vbemfTarget = 0) { + HAPTICS_TRACE( + " constructPwleSegment(ch, delay:%u, amplitude:%u, frequency:%u, flags:%u" + ", vbemfTarget:%u)", + delay, amplitude, frequency, flags, vbemfTarget); + write(16, delay); + write(12, amplitude); + write(12, frequency); + /* feature flags to control the chirp, CLAB braking, back EMF amplitude regulation */ + write(8, (flags | 1) << 4); + if (flags & PWLE_AMP_REG_BIT) { + write(24, vbemfTarget); /* target back EMF voltage */ + } + } - return ch; -} + public: + uint8_t *front() const { return head.get(); } + uint8_t type() const { return waveformType; } + size_t size() const { return bytes; } + + DspMemChunk(uint8_t type, size_t size) : head(new uint8_t[size]{0x00}) { + HAPTICS_TRACE(" DspMemChunk(size:%zu)", size); + waveformType = type; + _current = head.get(); + _max = _current + size; + + if (waveformType == WAVEFORM_COMPOSE) { + write(8, 0); /* Padding */ + write(8, 0); /* nsections placeholder */ + write(8, 0); /* repeat */ + } else if (waveformType == WAVEFORM_PWLE) { + write(24, 0); /* Waveform length placeholder */ + write(8, 0); /* Repeat */ + write(12, 0); /* Wait time between repeats */ + write(8, 0); /* nsections placeholder */ + } else { + ALOGE("%s: Invalid type: %u", __func__, waveformType); + } + } -static bool dspmem_chunk_end(struct dspmem_chunk *ch) { - return ch->current == ch->max; -} + int flush() { + HAPTICS_TRACE(" DspMemChunk::flush()"); + if (!_cachebits) + return 0; -static int dspmem_chunk_bytes(struct dspmem_chunk *ch) { - return ch->bytes; -} + return write(24 - _cachebits, 0); + } -static int dspmem_chunk_write(struct dspmem_chunk *ch, int nbits, uint32_t val) { - int nwrite, i; + int constructComposeSegment(uint32_t effectVolLevel, uint32_t effectIndex, uint8_t repeat, + uint8_t flags, uint16_t nextEffectDelay) { + HAPTICS_TRACE( + " constructComposeSegment(effectVolLevel:%u, effectIndex:%u, repeat:%d, " + "flags:%d, nextEffectDelay:%u", + effectVolLevel, effectIndex, repeat, flags, nextEffectDelay); + if (waveformType != WAVEFORM_COMPOSE) { + ALOGE("%s: Invalid type: %d", __func__, waveformType); + return -EDOM; + } + if (effectVolLevel > 100 || effectIndex > WAVEFORM_MAX_PHYSICAL_INDEX) { + ALOGE("%s: Invalid argument: %u, %u", __func__, effectVolLevel, effectIndex); + return -EINVAL; + } + write(8, effectVolLevel); /* amplitude */ + write(8, effectIndex); /* index */ + write(8, repeat); /* repeat */ + write(8, flags); /* flags */ + write(16, nextEffectDelay); /* delay */ + return 0; + } - nwrite = min(24 - ch->cachebits, nbits); - ch->cache <<= nwrite; - ch->cache |= val >> (nbits - nwrite); - ch->cachebits += nwrite; - nbits -= nwrite; + int constructActiveSegment(int duration, float amplitude, float frequency, bool chirp) { + HAPTICS_TRACE(" constructActiveSegment(duration:%d, amplitude:%f, frequency:%f)", + duration, amplitude, frequency); + uint16_t delay = 0; + uint16_t amp = 0; + uint16_t freq = 0; + uint8_t flags = 0x0; + if (waveformType != WAVEFORM_PWLE) { + ALOGE("%s: Invalid type: %d", __func__, waveformType); + return -EDOM; + } + if ((fToU16(duration, &delay, 4, 0.0f, COMPOSE_PWLE_PRIMITIVE_DURATION_MAX_MS) < 0) || + (fToU16(amplitude, &, 2048, CS40L26_PWLE_LEVEL_MIN, CS40L26_PWLE_LEVEL_MAX) < 0) || + (fToU16(frequency, &freq, 4, PWLE_FREQUENCY_MIN_HZ, PWLE_FREQUENCY_MAX_HZ) < 0)) { + ALOGE("%s: Invalid argument: %d, %f, %f", __func__, duration, amplitude, frequency); + return -ERANGE; + } + if (chirp) { + flags |= PWLE_CHIRP_BIT; + } + constructPwleSegment(delay, amp, freq, flags, 0 /*ignored*/); + return 0; + } - if (ch->cachebits == 24) { - if (dspmem_chunk_end(ch)) - return -ENOSPC; + int constructBrakingSegment(int duration, Braking brakingType) { + HAPTICS_TRACE(" constructBrakingSegment(duration:%d, brakingType:%s)", duration, + toString(brakingType).c_str()); + uint16_t delay = 0; + uint16_t freq = 0; + uint8_t flags = 0x00; + if (waveformType != WAVEFORM_PWLE) { + ALOGE("%s: Invalid type: %d", __func__, waveformType); + return -EDOM; + } + if (fToU16(duration, &delay, 4, 0.0f, COMPOSE_PWLE_PRIMITIVE_DURATION_MAX_MS) < 0) { + ALOGE("%s: Invalid argument: %d", __func__, duration); + return -ERANGE; + } + fToU16(PWLE_FREQUENCY_MIN_HZ, &freq, 4, PWLE_FREQUENCY_MIN_HZ, PWLE_FREQUENCY_MAX_HZ); + if (static_cast<std::underlying_type<Braking>::type>(brakingType)) { + flags |= PWLE_BRAKE_BIT; + } - ch->cache &= 0xFFFFFF; - for (i = 0; i < sizeof(ch->cache); i++, ch->cache <<= 8) - *ch->current++ = (ch->cache & 0xFF000000) >> 24; + constructPwleSegment(delay, 0 /*ignored*/, freq, flags, 0 /*ignored*/); + return 0; + } - ch->bytes += sizeof(ch->cache); - ch->cachebits = 0; + int updateWLength(uint32_t totalDuration) { + HAPTICS_TRACE(" updateWLength(totalDuration:%u)", totalDuration); + uint8_t *f = front(); + if (f == nullptr) { + ALOGE("%s: head does not exist!", __func__); + return -ENOMEM; + } + if (waveformType != WAVEFORM_PWLE) { + ALOGE("%s: Invalid type: %d", __func__, waveformType); + return -EDOM; + } + if (totalDuration > 0x7FFFF) { + ALOGE("%s: Invalid argument: %u", __func__, totalDuration); + return -EINVAL; + } + totalDuration *= 8; /* Unit: 0.125 ms (since wlength played @ 8kHz). */ + totalDuration |= + WT_LEN_CALCD; /* Bit 23 is for WT_LEN_CALCD; Bit 22 is for WT_INDEFINITE. */ + *(f + 0) = (totalDuration >> 24) & 0xFF; + *(f + 1) = (totalDuration >> 16) & 0xFF; + *(f + 2) = (totalDuration >> 8) & 0xFF; + *(f + 3) = totalDuration & 0xFF; + return 0; } - if (nbits) - return dspmem_chunk_write(ch, nbits, val); + int updateNSection(int segmentIdx) { + HAPTICS_TRACE(" updateNSection(segmentIdx:%u)", segmentIdx); + uint8_t *f = front(); + if (f == nullptr) { + ALOGE("%s: head does not exist!", __func__); + return -ENOMEM; + } - return 0; -} + if (waveformType == WAVEFORM_COMPOSE) { + if (segmentIdx > COMPOSE_SIZE_MAX + 1 /*1st effect may have a delay*/) { + ALOGE("%s: Invalid argument: %d", __func__, segmentIdx); + return -EINVAL; + } + *(f + 2) = (0xFF & segmentIdx); + } else if (waveformType == WAVEFORM_PWLE) { + if (segmentIdx > COMPOSE_PWLE_SIZE_MAX_DEFAULT) { + ALOGE("%s: Invalid argument: %d", __func__, segmentIdx); + return -EINVAL; + } + *(f + 7) |= (0xF0 & segmentIdx) >> 4; /* Bit 4 to 7 */ + *(f + 9) |= (0x0F & segmentIdx) << 4; /* Bit 3 to 0 */ + } else { + ALOGE("%s: Invalid type: %d", __func__, waveformType); + return -EDOM; + } -static int dspmem_chunk_flush(struct dspmem_chunk *ch) { - if (!ch->cachebits) return 0; + } +}; - return dspmem_chunk_write(ch, 24 - ch->cachebits, 0); -} +// Discrete points of frequency:max_level pairs around resonant(145Hz default) frequency +// Initialize the actuator LUXSHARE_ICT_081545 limits to 0.447 and others 1.0 +#if defined(LUXSHARE_ICT_081545) +static std::map<float, float> discretePwleMaxLevels = { + {120.0, 0.447}, {130.0, 0.346}, {140.0, 0.156}, {145.0, 0.1}, + {150.0, 0.167}, {160.0, 0.391}, {170.0, 0.447}}; +std::vector<float> pwleMaxLevelLimitMap(PWLE_BW_MAP_SIZE, 0.447); +#else +static std::map<float, float> discretePwleMaxLevels = {}; +std::vector<float> pwleMaxLevelLimitMap(PWLE_BW_MAP_SIZE, 1.0); +#endif -std::vector<struct ff_effect> mFfEffects; +static float redcToFloat(std::string *caldata) { + return static_cast<float>(std::stoul(*caldata, nullptr, 16)) / (1 << Q15_BIT_SHIFT); +} -Vibrator::Vibrator(std::unique_ptr<HwApi> hwapi, std::unique_ptr<HwCal> hwcal) - : mHwApi(std::move(hwapi)), mHwCal(std::move(hwcal)), mAsyncHandle(std::async([] {})) { +Vibrator::Vibrator(std::unique_ptr<HwApi> hwapi, std::unique_ptr<HwCal> hwcal, + std::unique_ptr<StatsApi> statsapi) + : mHwApi(std::move(hwapi)), + mHwCal(std::move(hwcal)), + mStatsApi(std::move(statsapi)), + mAsyncHandle(std::async([] {})) { int32_t longFrequencyShift; std::string caldata{8, '0'}; uint32_t calVer; + const std::string INPUT_EVENT_NAME = std::getenv("INPUT_EVENT_NAME") ?: ""; - glob_t inputEventPaths; - int fd = -1; - int ret; - uint32_t val = 0; - char str[20] = {0x00}; - const char *inputEventName = std::getenv("INPUT_EVENT_NAME"); - for (uint8_t retry = 0; retry < 10; retry++) { - ret = glob("/dev/input/event*", 0, nullptr, &inputEventPaths); - if (ret) { - ALOGE("Fail to get input event paths (%d): %s", errno, strerror(errno)); - } else { - for (int i = 0; i < inputEventPaths.gl_pathc; i++) { - fd = TEMP_FAILURE_RETRY(open(inputEventPaths.gl_pathv[i], O_RDWR)); - if (fd > 0) { - if (ioctl(fd, EVIOCGBIT(0, sizeof(val)), &val) > 0 && (val & (1 << EV_FF)) && - ioctl(fd, EVIOCGNAME(sizeof(str)), &str) > 0 && - strcmp(str, inputEventName) == 0) { - mInputFd.reset(fd); - ALOGI("Control %s through %s", inputEventName, inputEventPaths.gl_pathv[i]); - break; - } - close(fd); - } - } - } - - if (ret == 0) { - globfree(&inputEventPaths); - } - if (mInputFd.ok()) { - break; - } - - sleep(1); - ALOGW("Retry #%d to search in %zu input devices.", retry, inputEventPaths.gl_pathc); - } - - if (!mInputFd.ok()) { - ALOGE("Fail to get an input event with name %s", inputEventName); - return; - } - - /* - * Create custom effects for all physical waveforms. - * 1. Set the initial duration for the corresponding RAM waveform. - * 2. Write to the force feedback driver. If the waveform firmware is not loaded, - * retry at most 10 times and then abort the constructor. - * 3. Store the effect ID. - */ - uint8_t retry = 0; mFfEffects.resize(WAVEFORM_MAX_INDEX); mEffectDurations.resize(WAVEFORM_MAX_INDEX); mEffectDurations = { - 1000, 100, 30, 1000, 300, 130, 150, 500, 100, 15, 20, 1000, 1000, 1000, + 1000, 100, 12, 1000, 300, 130, 150, 500, 100, 5, 12, 1000, 1000, 1000, }; /* 11+3 waveforms. The duration must < UINT16_MAX */ + mEffectCustomData.reserve(WAVEFORM_MAX_INDEX); - uint8_t effectIndex = 0; - const uint8_t owtPlaceholder[] = {0x00, 0x00, 0x01, 0x00, 0x00, 0x5F, - 0x02, 0x00, 0x00, 0x00, 0x00, 0x00}; - const uint8_t owtPlaceholderLength = sizeof(owtPlaceholder); + uint8_t effectIndex; + uint16_t numBytes = 0; for (effectIndex = 0; effectIndex < WAVEFORM_MAX_INDEX; effectIndex++) { if (effectIndex < WAVEFORM_MAX_PHYSICAL_INDEX) { + /* Initialize physical waveforms. */ + mEffectCustomData.push_back({RAM_WVFRM_BANK, effectIndex}); mFfEffects[effectIndex] = { .type = FF_PERIODIC, .id = -1, .replay.length = static_cast<uint16_t>(mEffectDurations[effectIndex]), .u.periodic.waveform = FF_CUSTOM, - .u.periodic.custom_data = new int16_t[2]{RAM_WVFRM_BANK, effectIndex}, - .u.periodic.custom_len = FF_CUSTOM_DATA_LEN, + .u.periodic.custom_data = mEffectCustomData[effectIndex].data(), + .u.periodic.custom_len = + static_cast<uint32_t>(mEffectCustomData[effectIndex].size()), }; + // Bypass the waveform update due to different input name + if (INPUT_EVENT_NAME.find("cs40l26") != std::string::npos) { + if (!mHwApi->setFFEffect( + &mFfEffects[effectIndex], + static_cast<uint16_t>(mFfEffects[effectIndex].replay.length))) { + mStatsApi->logError(kHwApiError); + ALOGE("Failed upload effect %d (%d): %s", effectIndex, errno, strerror(errno)); + } + } + if (mFfEffects[effectIndex].id != effectIndex) { + ALOGW("Unexpected effect index: %d -> %d", effectIndex, mFfEffects[effectIndex].id); + } } else { /* Initiate placeholders for OWT effects. */ + numBytes = effectIndex == WAVEFORM_COMPOSE ? FF_CUSTOM_DATA_LEN_MAX_COMP + : FF_CUSTOM_DATA_LEN_MAX_PWLE; + std::vector<int16_t> tempVec(numBytes, 0); + mEffectCustomData.push_back(std::move(tempVec)); mFfEffects[effectIndex] = { .type = FF_PERIODIC, .id = -1, .replay.length = 0, .u.periodic.waveform = FF_CUSTOM, - .u.periodic.custom_data = nullptr, - .u.periodic.custom_len = owtPlaceholderLength / sizeof(int16_t), + .u.periodic.custom_data = mEffectCustomData[effectIndex].data(), + .u.periodic.custom_len = 0, }; - mFfEffects[effectIndex].u.periodic.custom_data = - new int16_t[mFfEffects[effectIndex].u.periodic.custom_len]{0x0000}; - memcpy(mFfEffects[effectIndex].u.periodic.custom_data, owtPlaceholder, - owtPlaceholderLength); - } - - while (true) { - if (ioctl(mInputFd, EVIOCSFF, &mFfEffects[effectIndex]) < 0) { - ALOGE("Failed upload effect %d (%d): %s", effectIndex, errno, strerror(errno)); - - if (retry < 10) { - sleep(1); - ALOGW("Retry #%u", ++retry); - continue; - } else { - ALOGE("Retried but the initialization was failed!"); - return; - } - } - mFfEffects[effectIndex].id = effectIndex; - break; } } - if (effectIndex != WAVEFORM_MAX_INDEX) { - ALOGE("Incomplete effect initialization!"); - return; - } if (mHwCal->getF0(&caldata)) { mHwApi->setF0(caldata); + mResonantFrequency = + static_cast<float>(std::stoul(caldata, nullptr, 16)) / (1 << Q14_BIT_SHIFT); + } else { + mStatsApi->logError(kHwCalError); + ALOGE("Failed to get resonant frequency (%d): %s, using default resonant HZ: %f", errno, + strerror(errno), RESONANT_FREQUENCY_DEFAULT); + mResonantFrequency = RESONANT_FREQUENCY_DEFAULT; } if (mHwCal->getRedc(&caldata)) { mHwApi->setRedc(caldata); + mRedc = redcToFloat(&caldata); } if (mHwCal->getQ(&caldata)) { mHwApi->setQ(caldata); @@ -375,11 +488,12 @@ Vibrator::Vibrator(std::unique_ptr<HwApi> hwapi, std::unique_ptr<HwCal> hwcal) mHwCal->getClickVolLevels(&mClickEffectVol); mHwCal->getLongVolLevels(&mLongEffectVol); } else { - ALOGW("Unsupported calibration version!"); + ALOGD("Unsupported calibration version: %u!", calVer); } + HAPTICS_TRACE("Vibrator(hwapi, hwcal:%u)", calVer); - mHwApi->setF0CompEnable(true); - mHwApi->setRedcCompEnable(true); + mHwApi->setF0CompEnable(mHwCal->isF0CompEnabled()); + mHwApi->setRedcCompEnable(mHwCal->isRedcCompEnabled()); mIsUnderExternalControl = false; @@ -400,20 +514,36 @@ Vibrator::Vibrator(std::unique_ptr<HwApi> hwapi, std::unique_ptr<HwCal> hwcal) } mHwApi->setMinOnOffInterval(MIN_ON_OFF_INTERVAL_US); + + createPwleMaxLevelLimitMap(); + createBandwidthAmplitudeMap(); + +#ifdef ADAPTIVE_HAPTICS_V1 + mContextListener = CapoDetector::start(); + if (mContextListener == nullptr) { + ALOGE("%s, CapoDetector failed to start", __func__); + } else { + ALOGD("%s, CapoDetector started successfully! NanoAppID: 0x%x", __func__, + (uint32_t)mContextListener->getNanoppAppId()); + } +#endif /*ADAPTIVE_HAPTICS_V1*/ } ndk::ScopedAStatus Vibrator::getCapabilities(int32_t *_aidl_return) { + HAPTICS_TRACE("getCapabilities(_aidl_return)"); ATRACE_NAME("Vibrator::getCapabilities"); int32_t ret = IVibrator::CAP_ON_CALLBACK | IVibrator::CAP_PERFORM_CALLBACK | - IVibrator::CAP_AMPLITUDE_CONTROL | IVibrator::CAP_ALWAYS_ON_CONTROL | - IVibrator::CAP_GET_RESONANT_FREQUENCY | IVibrator::CAP_GET_Q_FACTOR; + IVibrator::CAP_AMPLITUDE_CONTROL | IVibrator::CAP_GET_RESONANT_FREQUENCY | + IVibrator::CAP_GET_Q_FACTOR; if (hasHapticAlsaDevice()) { ret |= IVibrator::CAP_EXTERNAL_CONTROL; + } else { + mStatsApi->logError(kAlsaFailError); + ALOGE("No haptics ALSA device"); } if (mHwApi->hasOwtFreeSpace()) { ret |= IVibrator::CAP_COMPOSE_EFFECTS; - if (mIsChirpEnabled) { ret |= IVibrator::CAP_FREQUENCY_CONTROL | IVibrator::CAP_COMPOSE_PWLE_EFFECTS; } @@ -423,32 +553,50 @@ ndk::ScopedAStatus Vibrator::getCapabilities(int32_t *_aidl_return) { } ndk::ScopedAStatus Vibrator::off() { + HAPTICS_TRACE("off()"); ATRACE_NAME("Vibrator::off"); - if (mActiveId < 0) { - return ndk::ScopedAStatus::ok(); - } - - struct input_event play = { - .type = EV_FF, - .code = static_cast<uint16_t>(mActiveId), - .value = 0, - }; + bool ret{true}; + const std::scoped_lock<std::mutex> lock(mActiveId_mutex); + + if (mActiveId >= 0) { + /* Stop the active effect. */ + if (!mHwApi->setFFPlay(mActiveId, false)) { + mStatsApi->logError(kHwApiError); + ALOGE("Failed to stop effect %d (%d): %s", mActiveId, errno, strerror(errno)); + ret = false; + } - if (write(mInputFd, (const void *)&play, sizeof(play)) != sizeof(play)) { - ALOGE("Failed to stop effect %d (%d): %s", play.code, errno, strerror(errno)); - return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); + if ((mActiveId >= WAVEFORM_MAX_PHYSICAL_INDEX) && + (!mHwApi->eraseOwtEffect(mActiveId, &mFfEffects))) { + mStatsApi->logError(kHwApiError); + ALOGE("Failed to clean up the composed effect %d", mActiveId); + ret = false; + } + } else { + ALOGV("Vibrator is already off"); } mActiveId = -1; setGlobalAmplitude(false); - mHwApi->setF0Offset(0); - return ndk::ScopedAStatus::ok(); + if (mF0Offset) { + mHwApi->setF0Offset(0); + } + + if (ret) { + return ndk::ScopedAStatus::ok(); + } else { + return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); + } } ndk::ScopedAStatus Vibrator::on(int32_t timeoutMs, const std::shared_ptr<IVibratorCallback> &callback) { - ATRACE_NAME("Vibrator::on"); + ATRACE_NAME(StringPrintf("Vibrator::on %dms", timeoutMs).c_str()); + HAPTICS_TRACE("on(timeoutMs:%d, callback)", timeoutMs); + + mStatsApi->logLatencyStart(kWaveformEffectLatency); if (timeoutMs > MAX_TIME_MS) { + mStatsApi->logError(kBadTimeoutError); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } const uint16_t index = (timeoutMs < WAVEFORM_LONG_VIBRATION_THRESHOLD_MS) @@ -458,26 +606,40 @@ ndk::ScopedAStatus Vibrator::on(int32_t timeoutMs, timeoutMs += MAX_COLD_START_LATENCY_MS; } setGlobalAmplitude(true); - mHwApi->setF0Offset(mF0Offset); - return on(timeoutMs, index, callback); + if (mF0Offset) { + mHwApi->setF0Offset(mF0Offset); + } + + mStatsApi->logWaveform(index, timeoutMs); + return on(timeoutMs, index, nullptr /*ignored*/, callback); } ndk::ScopedAStatus Vibrator::perform(Effect effect, EffectStrength strength, const std::shared_ptr<IVibratorCallback> &callback, int32_t *_aidl_return) { - ATRACE_NAME("Vibrator::perform"); + ATRACE_NAME(StringPrintf("Vibrator::perform %s,%s", toString(effect).c_str(), + toString(strength).c_str()) + .c_str()); + HAPTICS_TRACE("perform(effect:%s, strength:%s, callback, _aidl_return)", + toString(effect).c_str(), toString(strength).c_str()); + + mStatsApi->logLatencyStart(kPrebakedEffectLatency); + return performEffect(effect, strength, callback, _aidl_return); } ndk::ScopedAStatus Vibrator::getSupportedEffects(std::vector<Effect> *_aidl_return) { + HAPTICS_TRACE("getSupportedEffects(_aidl_return)"); *_aidl_return = {Effect::TEXTURE_TICK, Effect::TICK, Effect::CLICK, Effect::HEAVY_CLICK, Effect::DOUBLE_CLICK}; return ndk::ScopedAStatus::ok(); } ndk::ScopedAStatus Vibrator::setAmplitude(float amplitude) { + HAPTICS_TRACE("setAmplitude(amplitude:%f)", amplitude); ATRACE_NAME("Vibrator::setAmplitude"); if (amplitude <= 0.0f || amplitude > 1.0f) { + mStatsApi->logError(kBadAmplitudeError); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } @@ -485,19 +647,26 @@ ndk::ScopedAStatus Vibrator::setAmplitude(float amplitude) { if (!isUnderExternalControl()) { return setGlobalAmplitude(true); } else { + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } } ndk::ScopedAStatus Vibrator::setExternalControl(bool enabled) { + HAPTICS_TRACE("setExternalControl(enabled:%u)", enabled); ATRACE_NAME("Vibrator::setExternalControl"); setGlobalAmplitude(enabled); - if (mHasHapticAlsaDevice) { - if (!enableHapticPcmAmp(&mHapticPcm, enabled, mCard, mDevice)) { + if (mHasHapticAlsaDevice || mConfigHapticAlsaDeviceDone || hasHapticAlsaDevice()) { + if (!mHwApi->setHapticPcmAmp(&mHapticPcm, enabled, mCard, mDevice)) { + mStatsApi->logError(kHwApiError); ALOGE("Failed to %s haptic pcm device: %d", (enabled ? "enable" : "disable"), mDevice); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); } + } else { + mStatsApi->logError(kAlsaFailError); + ALOGE("No haptics ALSA device"); + return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); } mIsUnderExternalControl = enabled; @@ -505,24 +674,28 @@ ndk::ScopedAStatus Vibrator::setExternalControl(bool enabled) { } ndk::ScopedAStatus Vibrator::getCompositionDelayMax(int32_t *maxDelayMs) { + HAPTICS_TRACE("getCompositionDelayMax(maxDelayMs)"); ATRACE_NAME("Vibrator::getCompositionDelayMax"); *maxDelayMs = COMPOSE_DELAY_MAX_MS; return ndk::ScopedAStatus::ok(); } ndk::ScopedAStatus Vibrator::getCompositionSizeMax(int32_t *maxSize) { + HAPTICS_TRACE("getCompositionSizeMax(maxSize)"); ATRACE_NAME("Vibrator::getCompositionSizeMax"); *maxSize = COMPOSE_SIZE_MAX; return ndk::ScopedAStatus::ok(); } ndk::ScopedAStatus Vibrator::getSupportedPrimitives(std::vector<CompositePrimitive> *supported) { + HAPTICS_TRACE("getSupportedPrimitives(supported)"); *supported = mSupportedPrimitives; return ndk::ScopedAStatus::ok(); } ndk::ScopedAStatus Vibrator::getPrimitiveDuration(CompositePrimitive primitive, int32_t *durationMs) { + HAPTICS_TRACE("getPrimitiveDuration(primitive:%s, durationMs)", toString(primitive).c_str()); ndk::ScopedAStatus status; uint32_t effectIndex; if (primitive != CompositePrimitive::NOOP) { @@ -540,20 +713,26 @@ ndk::ScopedAStatus Vibrator::getPrimitiveDuration(CompositePrimitive primitive, ndk::ScopedAStatus Vibrator::compose(const std::vector<CompositeEffect> &composite, const std::shared_ptr<IVibratorCallback> &callback) { - ATRACE_NAME("Vibrator::compose"); + ATRACE_NAME(StringPrintf("Vibrator::compose size=%zu", composite.size()).c_str()); + HAPTICS_TRACE("compose(composite, callback)"); uint16_t size; uint16_t nextEffectDelay; + uint16_t totalDuration = 0; - auto ch = dspmem_chunk_create(new uint8_t[FF_CUSTOM_DATA_LEN_MAX_COMP]{0x00}, - FF_CUSTOM_DATA_LEN_MAX_COMP); + mStatsApi->logLatencyStart(kCompositionEffectLatency); if (composite.size() > COMPOSE_SIZE_MAX || composite.empty()) { + ALOGE("%s: Invalid size", __func__); + mStatsApi->logError(kBadCompositeError); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } /* Check if there is a wait before the first effect. */ nextEffectDelay = composite.front().delayMs; + totalDuration += nextEffectDelay; if (nextEffectDelay > COMPOSE_DELAY_MAX_MS || nextEffectDelay < 0) { + ALOGE("%s: Invalid delay %u", __func__, nextEffectDelay); + mStatsApi->logError(kBadCompositeError); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } else if (nextEffectDelay > 0) { size = composite.size() + 1; @@ -561,15 +740,13 @@ ndk::ScopedAStatus Vibrator::compose(const std::vector<CompositeEffect> &composi size = composite.size(); } - dspmem_chunk_write(ch, 8, 0); /* Padding */ - dspmem_chunk_write(ch, 8, (uint8_t)(0xFF & size)); /* nsections */ - dspmem_chunk_write(ch, 8, 0); /* repeat */ - uint8_t header_count = ch->bytes; + DspMemChunk ch(WAVEFORM_COMPOSE, FF_CUSTOM_DATA_LEN_MAX_COMP); + const uint8_t header_count = ch.size(); /* Insert 1 section for a wait before the first effect. */ if (nextEffectDelay) { - dspmem_chunk_write(ch, 32, 0); /* amplitude, index, repeat & flags */ - dspmem_chunk_write(ch, 16, (uint16_t)(0xFFFF & nextEffectDelay)); /* delay */ + ch.constructComposeSegment(0 /*amplitude*/, 0 /*index*/, 0 /*repeat*/, 0 /*flags*/, + nextEffectDelay /*delay*/); } for (uint32_t i_curr = 0, i_next = 1; i_curr < composite.size(); i_curr++, i_next++) { @@ -577,6 +754,8 @@ ndk::ScopedAStatus Vibrator::compose(const std::vector<CompositeEffect> &composi uint32_t effectIndex = 0; uint32_t effectVolLevel = 0; if (e_curr.scale < 0.0f || e_curr.scale > 1.0f) { + ALOGE("%s: #%u: Invalid scale %f", __func__, i_curr, e_curr.scale); + mStatsApi->logError(kBadCompositeError); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } @@ -587,6 +766,7 @@ ndk::ScopedAStatus Vibrator::compose(const std::vector<CompositeEffect> &composi return status; } effectVolLevel = intensityToVolLevel(e_curr.scale, effectIndex); + totalDuration += mEffectDurations[effectIndex]; } /* Fetch the next composite effect delay and fill into the current section */ @@ -596,76 +776,198 @@ ndk::ScopedAStatus Vibrator::compose(const std::vector<CompositeEffect> &composi int32_t delay = e_next.delayMs; if (delay > COMPOSE_DELAY_MAX_MS || delay < 0) { + ALOGE("%s: #%u: Invalid delay %d", __func__, i_next, delay); + mStatsApi->logError(kBadCompositeError); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } nextEffectDelay = delay; + totalDuration += delay; } if (effectIndex == 0 && nextEffectDelay == 0) { + ALOGE("%s: #%u: Invalid results", __func__, i_curr); + mStatsApi->logError(kBadCompositeError); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } + mStatsApi->logPrimitive(effectIndex); + ch.constructComposeSegment(effectVolLevel, effectIndex, 0 /*repeat*/, 0 /*flags*/, + nextEffectDelay /*delay*/); + } - dspmem_chunk_write(ch, 8, (uint8_t)(0xFF & effectVolLevel)); /* amplitude */ - dspmem_chunk_write(ch, 8, (uint8_t)(0xFF & effectIndex)); /* index */ - dspmem_chunk_write(ch, 8, 0); /* repeat */ - dspmem_chunk_write(ch, 8, 0); /* flags */ - dspmem_chunk_write(ch, 16, (uint16_t)(0xFFFF & nextEffectDelay)); /* delay */ + ch.flush(); + if (ch.updateNSection(size) < 0) { + mStatsApi->logError(kComposeFailError); + ALOGE("%s: Failed to update the section count", __func__); + return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } - dspmem_chunk_flush(ch); - if (header_count == ch->bytes) { + if (header_count == ch.size()) { + ALOGE("%s: Failed to append effects", __func__); + mStatsApi->logError(kComposeFailError); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } else { - return performEffect(0 /*ignored*/, 0 /*ignored*/, ch, callback); + mFfEffects[WAVEFORM_COMPOSE].replay.length = totalDuration; + return performEffect(WAVEFORM_MAX_INDEX /*ignored*/, VOLTAGE_SCALE_MAX /*ignored*/, &ch, + callback); } } -ndk::ScopedAStatus Vibrator::on(uint32_t timeoutMs, uint32_t effectIndex, +ndk::ScopedAStatus Vibrator::on(uint32_t timeoutMs, uint32_t effectIndex, const DspMemChunk *ch, const std::shared_ptr<IVibratorCallback> &callback) { - if (effectIndex >= WAVEFORM_MAX_INDEX) { + HAPTICS_TRACE("on(timeoutMs:%u, effectIndex:%u, ch, callback)", timeoutMs, effectIndex); + ndk::ScopedAStatus status = ndk::ScopedAStatus::ok(); + + if (effectIndex >= FF_MAX_EFFECTS) { + mStatsApi->logError(kBadEffectError); ALOGE("Invalid waveform index %d", effectIndex); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } if (mAsyncHandle.wait_for(ASYNC_COMPLETION_TIMEOUT) != std::future_status::ready) { + mStatsApi->logError(kAsyncFailError); ALOGE("Previous vibration pending: prev: %d, curr: %d", mActiveId, effectIndex); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); } - /* Update duration for long/short vibration. */ - if (effectIndex == WAVEFORM_SHORT_VIBRATION_EFFECT_INDEX || - effectIndex == WAVEFORM_LONG_VIBRATION_EFFECT_INDEX) { + if (ch) { + /* Upload OWT effect. */ + if (ch->front() == nullptr) { + mStatsApi->logError(kBadCompositeError); + ALOGE("Invalid OWT bank"); + return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); + } + + if (ch->type() != WAVEFORM_PWLE && ch->type() != WAVEFORM_COMPOSE) { + mStatsApi->logError(kBadCompositeError); + ALOGE("Invalid OWT type"); + return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); + } + effectIndex = ch->type(); + + uint32_t freeBytes; + mHwApi->getOwtFreeSpace(&freeBytes); + if (ch->size() > freeBytes) { + mStatsApi->logError(kBadCompositeError); + ALOGE("Invalid OWT length: Effect %d: %zu > %d!", effectIndex, ch->size(), freeBytes); + return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); + } + int errorStatus; + if (!mHwApi->uploadOwtEffect(ch->front(), ch->size(), &mFfEffects[effectIndex], + &effectIndex, &errorStatus)) { + mStatsApi->logError(kHwApiError); + ALOGE("Invalid uploadOwtEffect"); + return ndk::ScopedAStatus::fromExceptionCode(errorStatus); + } + + } else if (effectIndex == WAVEFORM_SHORT_VIBRATION_EFFECT_INDEX || + effectIndex == WAVEFORM_LONG_VIBRATION_EFFECT_INDEX) { + /* Update duration for long/short vibration. */ mFfEffects[effectIndex].replay.length = static_cast<uint16_t>(timeoutMs); - if (ioctl(mInputFd, EVIOCSFF, &mFfEffects[effectIndex]) < 0) { + if (!mHwApi->setFFEffect(&mFfEffects[effectIndex], static_cast<uint16_t>(timeoutMs))) { + mStatsApi->logError(kHwApiError); ALOGE("Failed to edit effect %d (%d): %s", effectIndex, errno, strerror(errno)); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); } } + const std::scoped_lock<std::mutex> lock(mActiveId_mutex); + mActiveId = effectIndex; /* Play the event now. */ - struct input_event play = { - .type = EV_FF, - .code = static_cast<uint16_t>(effectIndex), - .value = 1, - }; - if (write(mInputFd, (const void *)&play, sizeof(play)) != sizeof(play)) { - ALOGE("Failed to play effect %d (%d): %s", play.code, errno, strerror(errno)); + mStatsApi->logLatencyEnd(); + if (!mHwApi->setFFPlay(effectIndex, true)) { + mStatsApi->logError(kHwApiError); + ALOGE("Failed to play effect %d (%d): %s", effectIndex, errno, strerror(errno)); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); } - mActiveId = play.code; - mAsyncHandle = std::async(&Vibrator::waitForComplete, this, callback); - return ndk::ScopedAStatus::ok(); } -ndk::ScopedAStatus Vibrator::setEffectAmplitude(float amplitude, float maximum) { - uint16_t scale = amplitudeToScale(amplitude, maximum); - struct input_event gain = { - .type = EV_FF, - .code = FF_GAIN, - .value = scale, - }; - if (write(mInputFd, (const void *)&gain, sizeof(gain)) != sizeof(gain)) { +uint16_t Vibrator::amplitudeToScale(float amplitude, float maximum, bool scalable) { + HAPTICS_TRACE("amplitudeToScale(amplitude:%f, maximum:%f, scalable:%d)", amplitude, maximum, + scalable ? 1 : 0); + float ratio = 100; /* Unit: % */ + + if (maximum != 0) + ratio = amplitude / maximum * 100; + + if (maximum == 0 || ratio > 100) + ratio = 100; + +#ifdef ADAPTIVE_HAPTICS_V1 + if (scalable && mContextEnable) { + uint32_t now = CapoDetector::getCurrentTimeInMs(); + uint32_t last_played = mLastEffectPlayedTime; + uint32_t lastFaceUpTime = 0; + uint8_t carriedPosition = 0; + float context_scale = 1.0; + bool device_face_up = false; + float pre_scaled_ratio = ratio; + mLastEffectPlayedTime = now; + + mContextListener->getCarriedPositionInfo(&carriedPosition, &lastFaceUpTime); + device_face_up = carriedPosition == capo::PositionType::ON_TABLE_FACE_UP; + + ALOGD("Vibrator Now: %u, Last: %u, ScaleTime: %u, Since? %d", now, lastFaceUpTime, + mScaleTime, (now < lastFaceUpTime + mScaleTime)); + /* If the device is face-up or within the fade scaling range, find new scaling factor */ + if (device_face_up || now < lastFaceUpTime + mScaleTime) { + /* Device is face-up, so we will scale it down. Start with highest scaling factor */ + context_scale = mScalingFactor <= 100 ? static_cast<float>(mScalingFactor) / 100 : 1.0; + if (mFadeEnable && mScaleTime > 0 && (context_scale < 1.0) && + (now < lastFaceUpTime + mScaleTime) && !device_face_up) { + float fade_scale = + static_cast<float>(now - lastFaceUpTime) / static_cast<float>(mScaleTime); + context_scale += ((1.0 - context_scale) * fade_scale); + ALOGD("Vibrator fade scale applied: %f", fade_scale); + } + ratio *= context_scale; + ALOGD("Vibrator adjusting for face-up: pre: %f, post: %f", std::round(pre_scaled_ratio), + std::round(ratio)); + } + + /* If we haven't played an effect within the cooldown time, save the scaling factor */ + if ((now - last_played) > mScaleCooldown) { + ALOGD("Vibrator updating lastplayed scale, old: %f, new: %f", mLastPlayedScale, + context_scale); + mLastPlayedScale = context_scale; + } else { + /* Override the scale to match previously played scale */ + ratio = mLastPlayedScale * pre_scaled_ratio; + ALOGD("Vibrator repeating last scale: %f, new ratio: %f, duration since last: %u", + mLastPlayedScale, ratio, (now - last_played)); + } + } +#else + // Suppress compiler warning + (void)scalable; +#endif /*ADAPTIVE_HAPTICS_V1*/ + + return std::round(ratio); +} + +void Vibrator::updateContext() { + mContextEnable = mHwApi->getContextEnable(); + mFadeEnable = mHwApi->getContextFadeEnable(); + mScalingFactor = mHwApi->getContextScale(); + mScaleTime = mHwApi->getContextSettlingTime(); + mScaleCooldown = mHwApi->getContextCooldownTime(); +} + +ndk::ScopedAStatus Vibrator::setEffectAmplitude(float amplitude, float maximum, bool scalable) { + HAPTICS_TRACE("setEffectAmplitude(amplitude:%f, maximum:%f, scalable:%d)", amplitude, maximum, + scalable ? 1 : 0); + uint16_t scale; + +#ifdef ADAPTIVE_HAPTICS_V1 + if (scalable) { + updateContext(); + } +#endif /*ADAPTIVE_HAPTICS_V1*/ + + scale = amplitudeToScale(amplitude, maximum, scalable); + + if (!mHwApi->setFFGain(scale)) { + mStatsApi->logError(kHwApiError); ALOGE("Failed to set the gain to %u (%d): %s", scale, errno, strerror(errno)); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); } @@ -673,71 +975,41 @@ ndk::ScopedAStatus Vibrator::setEffectAmplitude(float amplitude, float maximum) } ndk::ScopedAStatus Vibrator::setGlobalAmplitude(bool set) { + HAPTICS_TRACE("setGlobalAmplitude(set:%u)", set); uint8_t amplitude = set ? roundf(mLongEffectScale * mLongEffectVol[1]) : VOLTAGE_SCALE_MAX; if (!set) { mLongEffectScale = 1.0; // Reset the scale for the later new effect. } - return setEffectAmplitude(amplitude, VOLTAGE_SCALE_MAX); + return setEffectAmplitude(amplitude, VOLTAGE_SCALE_MAX, set); } -ndk::ScopedAStatus Vibrator::getSupportedAlwaysOnEffects(std::vector<Effect> *_aidl_return) { - *_aidl_return = {Effect::TEXTURE_TICK, Effect::TICK, Effect::CLICK, Effect::HEAVY_CLICK}; - return ndk::ScopedAStatus::ok(); +ndk::ScopedAStatus Vibrator::getSupportedAlwaysOnEffects(std::vector<Effect> * /*_aidl_return*/) { + mStatsApi->logError(kUnsupportedOpError); + return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } -ndk::ScopedAStatus Vibrator::alwaysOnEnable(int32_t id, Effect effect, EffectStrength strength) { - ndk::ScopedAStatus status; - uint32_t effectIndex; - uint32_t timeMs; - uint32_t volLevel; - uint16_t scale; - status = getSimpleDetails(effect, strength, &effectIndex, &timeMs, &volLevel); - if (!status.isOk()) { - return status; - } - - scale = amplitudeToScale(volLevel, VOLTAGE_SCALE_MAX); - - switch (static_cast<AlwaysOnId>(id)) { - case AlwaysOnId::GPIO_RISE: - // mHwApi->setGpioRiseIndex(effectIndex); - // mHwApi->setGpioRiseScale(scale); - return ndk::ScopedAStatus::ok(); - case AlwaysOnId::GPIO_FALL: - // mHwApi->setGpioFallIndex(effectIndex); - // mHwApi->setGpioFallScale(scale); - return ndk::ScopedAStatus::ok(); - } - +ndk::ScopedAStatus Vibrator::alwaysOnEnable(int32_t /*id*/, Effect /*effect*/, + EffectStrength /*strength*/) { + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } -ndk::ScopedAStatus Vibrator::alwaysOnDisable(int32_t id) { - switch (static_cast<AlwaysOnId>(id)) { - case AlwaysOnId::GPIO_RISE: - // mHwApi->setGpioRiseIndex(0); - return ndk::ScopedAStatus::ok(); - case AlwaysOnId::GPIO_FALL: - // mHwApi->setGpioFallIndex(0); - return ndk::ScopedAStatus::ok(); - } - +ndk::ScopedAStatus Vibrator::alwaysOnDisable(int32_t /*id*/) { + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } ndk::ScopedAStatus Vibrator::getResonantFrequency(float *resonantFreqHz) { - std::string caldata{8, '0'}; - if (!mHwCal->getF0(&caldata)) { - ALOGE("Failed to get resonant frequency (%d): %s", errno, strerror(errno)); - return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); - } - *resonantFreqHz = static_cast<float>(std::stoul(caldata, nullptr, 16)) / (1 << Q14_BIT_SHIFT); + HAPTICS_TRACE("getResonantFrequency(resonantFreqHz)"); + *resonantFreqHz = mResonantFrequency; return ndk::ScopedAStatus::ok(); } ndk::ScopedAStatus Vibrator::getQFactor(float *qFactor) { + HAPTICS_TRACE("getQFactor(qFactor)"); std::string caldata{8, '0'}; if (!mHwCal->getQ(&caldata)) { + mStatsApi->logError(kHwCalError); ALOGE("Failed to get q factor (%d): %s", errno, strerror(errno)); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); } @@ -747,63 +1019,203 @@ ndk::ScopedAStatus Vibrator::getQFactor(float *qFactor) { } ndk::ScopedAStatus Vibrator::getFrequencyResolution(float *freqResolutionHz) { + HAPTICS_TRACE("getFrequencyResolution(freqResolutionHz)"); int32_t capabilities; Vibrator::getCapabilities(&capabilities); if (capabilities & IVibrator::CAP_FREQUENCY_CONTROL) { *freqResolutionHz = PWLE_FREQUENCY_RESOLUTION_HZ; return ndk::ScopedAStatus::ok(); } else { + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } } ndk::ScopedAStatus Vibrator::getFrequencyMinimum(float *freqMinimumHz) { + HAPTICS_TRACE("getFrequencyMinimum(freqMinimumHz)"); int32_t capabilities; Vibrator::getCapabilities(&capabilities); if (capabilities & IVibrator::CAP_FREQUENCY_CONTROL) { *freqMinimumHz = PWLE_FREQUENCY_MIN_HZ; return ndk::ScopedAStatus::ok(); } else { + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } } +void Vibrator::createPwleMaxLevelLimitMap() { + int32_t capabilities; + Vibrator::getCapabilities(&capabilities); + if (!(capabilities & IVibrator::CAP_FREQUENCY_CONTROL)) { + mStatsApi->logError(kUnsupportedOpError); + ALOGE("Frequency control not support."); + return; + } + + if (discretePwleMaxLevels.empty()) { + mStatsApi->logError(kInitError); + ALOGE("Discrete PWLE max level maps are empty."); + return; + } + + int32_t pwleMaxLevelLimitMapIdx = 0; + std::map<float, float>::iterator itr0 = discretePwleMaxLevels.begin(); + if (discretePwleMaxLevels.size() == 1) { + ALOGD("Discrete PWLE max level map size is 1"); + pwleMaxLevelLimitMapIdx = + (itr0->first - PWLE_FREQUENCY_MIN_HZ) / PWLE_FREQUENCY_RESOLUTION_HZ; + pwleMaxLevelLimitMap[pwleMaxLevelLimitMapIdx] = itr0->second; + return; + } + + auto itr1 = std::next(itr0, 1); + + while (itr1 != discretePwleMaxLevels.end()) { + float x0 = itr0->first; + float y0 = itr0->second; + float x1 = itr1->first; + float y1 = itr1->second; + const float ratioOfXY = ((y1 - y0) / (x1 - x0)); + pwleMaxLevelLimitMapIdx = + (itr0->first - PWLE_FREQUENCY_MIN_HZ) / PWLE_FREQUENCY_RESOLUTION_HZ; + + // FixLater: avoid floating point loop counters + // NOLINTBEGIN(clang-analyzer-security.FloatLoopCounter,cert-flp30-c) + for (float xp = x0; xp < (x1 + PWLE_FREQUENCY_RESOLUTION_HZ); + xp += PWLE_FREQUENCY_RESOLUTION_HZ) { + // NOLINTEND(clang-analyzer-security.FloatLoopCounter,cert-flp30-c) + float yp = y0 + ratioOfXY * (xp - x0); + + pwleMaxLevelLimitMap[pwleMaxLevelLimitMapIdx++] = yp; + } + + itr0++; + itr1++; + } +} + +void Vibrator::createBandwidthAmplitudeMap() { + // Use constant Q Factor of 10 from HW's suggestion + const float qFactor = 10.0f; + const float blSys = 1.1f; + const float gravity = 9.81f; + const float maxVoltage = 11.0f; + float deviceMass = 0, locCoeff = 0; + + mHwCal->getDeviceMass(&deviceMass); + mHwCal->getLocCoeff(&locCoeff); + if (!deviceMass || !locCoeff) { + mStatsApi->logError(kInitError); + ALOGE("Failed to get Device Mass: %f and Loc Coeff: %f", deviceMass, locCoeff); + return; + } + + // Resistance value need to be retrieved from calibration file + if (mRedc == 0.0) { + std::string caldata{8, '0'}; + if (mHwCal->getRedc(&caldata)) { + mHwApi->setRedc(caldata); + mRedc = redcToFloat(&caldata); + } else { + mStatsApi->logError(kHwCalError); + ALOGE("Failed to get resistance value from calibration file"); + return; + } + } + + std::vector<float> bandwidthAmplitudeMap(PWLE_BW_MAP_SIZE, 1.0); + + const float wnSys = mResonantFrequency * 2 * M_PI; + const float powWnSys = pow(wnSys, 2); + const float var2Para = wnSys / qFactor; + + float frequencyHz = PWLE_FREQUENCY_MIN_HZ; + float frequencyRadians = 0.0f; + float vLevel = 0.4473f; + float vSys = (mLongEffectVol[1] / 100.0) * maxVoltage * vLevel; + float maxAsys = 0; + const float amplitudeSysPara = blSys * locCoeff / mRedc / deviceMass; + + for (int i = 0; i < PWLE_BW_MAP_SIZE; i++) { + frequencyRadians = frequencyHz * 2 * M_PI; + vLevel = pwleMaxLevelLimitMap[i]; + vSys = (mLongEffectVol[1] / 100.0) * maxVoltage * vLevel; + + float var1 = pow((powWnSys - pow(frequencyRadians, 2)), 2); + float var2 = pow((var2Para * frequencyRadians), 2); + + float psysAbs = sqrt(var1 + var2); + // The equation and all related details can be found in the bug + float amplitudeSys = + (vSys * amplitudeSysPara) * pow(frequencyRadians, 2) / psysAbs / gravity; + // Record the maximum acceleration for the next for loop + if (amplitudeSys > maxAsys) + maxAsys = amplitudeSys; + + bandwidthAmplitudeMap[i] = amplitudeSys; + frequencyHz += PWLE_FREQUENCY_RESOLUTION_HZ; + } + // Scaled the map between 0 and 1.0 + if (maxAsys > 0) { + for (int j = 0; j < PWLE_BW_MAP_SIZE; j++) { + bandwidthAmplitudeMap[j] = + std::floor((bandwidthAmplitudeMap[j] / maxAsys) * 1000) / 1000; + } + mBandwidthAmplitudeMap = bandwidthAmplitudeMap; + mCreateBandwidthAmplitudeMapDone = true; + } else { + mCreateBandwidthAmplitudeMapDone = false; + } +} + ndk::ScopedAStatus Vibrator::getBandwidthAmplitudeMap(std::vector<float> *_aidl_return) { - // TODO(b/170919640): complete implementation + HAPTICS_TRACE("getBandwidthAmplitudeMap(_aidl_return)"); int32_t capabilities; Vibrator::getCapabilities(&capabilities); if (capabilities & IVibrator::CAP_FREQUENCY_CONTROL) { - std::vector<float> bandwidthAmplitudeMap(PWLE_BW_MAP_SIZE, 1.0); - *_aidl_return = bandwidthAmplitudeMap; - return ndk::ScopedAStatus::ok(); + if (!mCreateBandwidthAmplitudeMapDone) { + createPwleMaxLevelLimitMap(); + createBandwidthAmplitudeMap(); + } + *_aidl_return = mBandwidthAmplitudeMap; + return (!mBandwidthAmplitudeMap.empty()) + ? ndk::ScopedAStatus::ok() + : ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); } else { + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } } ndk::ScopedAStatus Vibrator::getPwlePrimitiveDurationMax(int32_t *durationMs) { + HAPTICS_TRACE("getPwlePrimitiveDurationMax(durationMs)"); int32_t capabilities; Vibrator::getCapabilities(&capabilities); if (capabilities & IVibrator::CAP_COMPOSE_PWLE_EFFECTS) { *durationMs = COMPOSE_PWLE_PRIMITIVE_DURATION_MAX_MS; return ndk::ScopedAStatus::ok(); } else { + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } } ndk::ScopedAStatus Vibrator::getPwleCompositionSizeMax(int32_t *maxSize) { + HAPTICS_TRACE("getPwleCompositionSizeMax(maxSize)"); int32_t capabilities; Vibrator::getCapabilities(&capabilities); if (capabilities & IVibrator::CAP_COMPOSE_PWLE_EFFECTS) { *maxSize = COMPOSE_PWLE_SIZE_MAX_DEFAULT; return ndk::ScopedAStatus::ok(); } else { + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } } ndk::ScopedAStatus Vibrator::getSupportedBraking(std::vector<Braking> *supported) { + HAPTICS_TRACE("getSupportedBraking(supported)"); int32_t capabilities; Vibrator::getCapabilities(&capabilities); if (capabilities & IVibrator::CAP_COMPOSE_PWLE_EFFECTS) { @@ -812,12 +1224,14 @@ ndk::ScopedAStatus Vibrator::getSupportedBraking(std::vector<Braking> *supported }; return ndk::ScopedAStatus::ok(); } else { + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } } static void resetPreviousEndAmplitudeEndFrequency(float *prevEndAmplitude, float *prevEndFrequency) { + HAPTICS_TRACE(" resetPreviousEndAmplitudeEndFrequency(prevEndAmplitude, prevEndFrequency)"); const float reset = -1.0; *prevEndAmplitude = reset; *prevEndFrequency = reset; @@ -827,80 +1241,24 @@ static void incrementIndex(int *index) { *index += 1; } -static void constructPwleSegment(dspmem_chunk *ch, uint16_t delay, uint16_t amplitude, - uint16_t frequency, uint8_t flags, uint32_t vbemfTarget = 0) { - dspmem_chunk_write(ch, 16, delay); - dspmem_chunk_write(ch, 12, amplitude); - dspmem_chunk_write(ch, 12, frequency); - /* feature flags to control the chirp, CLAB braking, back EMF amplitude regulation */ - dspmem_chunk_write(ch, 8, (flags | 1) << 4); - if (flags & PWLE_AMP_REG_BIT) { - dspmem_chunk_write(ch, 24, vbemfTarget); /* target back EMF voltage */ - } -} - -static int constructActiveSegment(dspmem_chunk *ch, int duration, float amplitude, float frequency, - bool chirp) { - uint16_t delay = 0; - uint16_t amp = 0; - uint16_t freq = 0; - uint8_t flags = 0x0; - if ((floatToUint16(duration, &delay, 4, 0.0f, COMPOSE_PWLE_PRIMITIVE_DURATION_MAX_MS) < 0) || - (floatToUint16(amplitude, &, 2048, CS40L26_PWLE_LEVEL_MIX, CS40L26_PWLE_LEVEL_MAX) < - 0) || - (floatToUint16(frequency, &freq, 4, PWLE_FREQUENCY_MIN_HZ, PWLE_FREQUENCY_MAX_HZ) < 0)) { - ALOGE("Invalid argument: %d, %f, %f", duration, amplitude, frequency); - return -ERANGE; - } - if (chirp) { - flags |= PWLE_CHIRP_BIT; - } - constructPwleSegment(ch, delay, amp, freq, flags, 0 /*ignored*/); - return 0; -} - -static int constructBrakingSegment(dspmem_chunk *ch, int duration, Braking brakingType) { - uint16_t delay = 0; - uint16_t freq = 0; - uint8_t flags = 0x00; - if (floatToUint16(duration, &delay, 4, 0.0f, COMPOSE_PWLE_PRIMITIVE_DURATION_MAX_MS) < 0) { - ALOGE("Invalid argument: %d", duration); - return -ERANGE; - } - floatToUint16(PWLE_FREQUENCY_MIN_HZ, &freq, 4, PWLE_FREQUENCY_MIN_HZ, PWLE_FREQUENCY_MAX_HZ); - if (static_cast<std::underlying_type<Braking>::type>(brakingType)) { - flags |= PWLE_BRAKE_BIT; - } - - constructPwleSegment(ch, delay, 0 /*ignored*/, freq, flags, 0 /*ignored*/); - return 0; -} - -static void updateWLength(dspmem_chunk *ch, uint32_t totalDuration) { - totalDuration *= 8; /* Unit: 0.125 ms (since wlength played @ 8kHz). */ - totalDuration |= WT_LEN_CALCD; /* Bit 23 is for WT_LEN_CALCD; Bit 22 is for WT_INDEFINITE. */ - *(ch->head + 0) = (totalDuration >> 24) & 0xFF; - *(ch->head + 1) = (totalDuration >> 16) & 0xFF; - *(ch->head + 2) = (totalDuration >> 8) & 0xFF; - *(ch->head + 3) = totalDuration & 0xFF; -} - -static void updateNSection(dspmem_chunk *ch, int segmentIdx) { - *(ch->head + 7) |= (0xF0 & segmentIdx) >> 4; /* Bit 4 to 7 */ - *(ch->head + 9) |= (0x0F & segmentIdx) << 4; /* Bit 3 to 0 */ -} - ndk::ScopedAStatus Vibrator::composePwle(const std::vector<PrimitivePwle> &composite, const std::shared_ptr<IVibratorCallback> &callback) { - ATRACE_NAME("Vibrator::composePwle"); + ATRACE_NAME(StringPrintf("Vibrator::composePwle size=%zu", composite.size()).c_str()); + HAPTICS_TRACE("composePwle(composite, callback)"); int32_t capabilities; + mStatsApi->logLatencyStart(kPwleEffectLatency); + Vibrator::getCapabilities(&capabilities); if ((capabilities & IVibrator::CAP_COMPOSE_PWLE_EFFECTS) == 0) { + ALOGE("%s: Not supported", __func__); + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } if (composite.empty() || composite.size() > COMPOSE_PWLE_SIZE_MAX_DEFAULT) { + ALOGE("%s: Invalid size", __func__); + mStatsApi->logError(kBadCompositeError); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } @@ -914,14 +1272,9 @@ ndk::ScopedAStatus Vibrator::composePwle(const std::vector<PrimitivePwle> &compo float prevEndAmplitude; float prevEndFrequency; resetPreviousEndAmplitudeEndFrequency(&prevEndAmplitude, &prevEndFrequency); - auto ch = dspmem_chunk_create(new uint8_t[FF_CUSTOM_DATA_LEN_MAX_PWLE]{0x00}, - FF_CUSTOM_DATA_LEN_MAX_PWLE); + DspMemChunk ch(WAVEFORM_PWLE, FF_CUSTOM_DATA_LEN_MAX_PWLE); bool chirp = false; - - dspmem_chunk_write(ch, 24, 0x000000); /* Waveform length placeholder */ - dspmem_chunk_write(ch, 8, 0); /* Repeat */ - dspmem_chunk_write(ch, 12, 0); /* Wait time between repeats */ - dspmem_chunk_write(ch, 8, 0x00); /* nsections placeholder */ + uint16_t c = 0; for (auto &e : composite) { switch (e.getTag()) { @@ -929,31 +1282,48 @@ ndk::ScopedAStatus Vibrator::composePwle(const std::vector<PrimitivePwle> &compo auto active = e.get<PrimitivePwle::active>(); if (active.duration < 0 || active.duration > COMPOSE_PWLE_PRIMITIVE_DURATION_MAX_MS) { + mStatsApi->logError(kBadPrimitiveError); + ALOGE("%s: #%u: active: Invalid duration %d", __func__, c, active.duration); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } if (active.startAmplitude < PWLE_LEVEL_MIN || active.startAmplitude > PWLE_LEVEL_MAX || active.endAmplitude < PWLE_LEVEL_MIN || active.endAmplitude > PWLE_LEVEL_MAX) { + mStatsApi->logError(kBadPrimitiveError); + ALOGE("%s: #%u: active: Invalid scale %f, %f", __func__, c, + active.startAmplitude, active.endAmplitude); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } if (active.startAmplitude > CS40L26_PWLE_LEVEL_MAX) { active.startAmplitude = CS40L26_PWLE_LEVEL_MAX; + ALOGD("%s: #%u: active: trim the start scale", __func__, c); } if (active.endAmplitude > CS40L26_PWLE_LEVEL_MAX) { active.endAmplitude = CS40L26_PWLE_LEVEL_MAX; + ALOGD("%s: #%u: active: trim the end scale", __func__, c); } if (active.startFrequency < PWLE_FREQUENCY_MIN_HZ || active.startFrequency > PWLE_FREQUENCY_MAX_HZ || active.endFrequency < PWLE_FREQUENCY_MIN_HZ || active.endFrequency > PWLE_FREQUENCY_MAX_HZ) { + mStatsApi->logError(kBadPrimitiveError); + ALOGE("%s: #%u: active: Invalid frequency %f, %f", __func__, c, + active.startFrequency, active.endFrequency); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } + /* Append a new segment if current and previous amplitude and + * frequency are not all the same. + */ if (!((active.startAmplitude == prevEndAmplitude) && (active.startFrequency == prevEndFrequency))) { - if (constructActiveSegment(ch, 0, active.startAmplitude, active.startFrequency, - false) < 0) { + if (ch.constructActiveSegment(0, active.startAmplitude, active.startFrequency, + false) < 0) { + mStatsApi->logError(kPwleConstructionFailError); + ALOGE("%s: #%u: active: Failed to construct for the start scale and " + "frequency %f, %f", + __func__, c, active.startAmplitude, active.startFrequency); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } incrementIndex(&segmentIdx); @@ -962,8 +1332,12 @@ ndk::ScopedAStatus Vibrator::composePwle(const std::vector<PrimitivePwle> &compo if (active.startFrequency != active.endFrequency) { chirp = true; } - if (constructActiveSegment(ch, active.duration, active.endAmplitude, - active.endFrequency, chirp) < 0) { + if (ch.constructActiveSegment(active.duration, active.endAmplitude, + active.endFrequency, chirp) < 0) { + mStatsApi->logError(kPwleConstructionFailError); + ALOGE("%s: #%u: active: Failed to construct for the end scale and frequency " + "%f, %f", + __func__, c, active.startAmplitude, active.startFrequency); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } incrementIndex(&segmentIdx); @@ -977,21 +1351,34 @@ ndk::ScopedAStatus Vibrator::composePwle(const std::vector<PrimitivePwle> &compo case PrimitivePwle::braking: { auto braking = e.get<PrimitivePwle::braking>(); if (braking.braking > Braking::CLAB) { + mStatsApi->logError(kBadPrimitiveError); + ALOGE("%s: #%u: braking: Invalid braking type %d", __func__, c, + braking.braking); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } else if (!isClabSupported && (braking.braking == Braking::CLAB)) { + mStatsApi->logError(kBadPrimitiveError); + ALOGE("%s: #%u: braking: Unsupported CLAB braking", __func__, c); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } if (braking.duration > COMPOSE_PWLE_PRIMITIVE_DURATION_MAX_MS) { + mStatsApi->logError(kBadPrimitiveError); + ALOGE("%s: #%u: braking: Invalid duration %d", __func__, c, braking.duration); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } - if (constructBrakingSegment(ch, 0, braking.braking) < 0) { + if (ch.constructBrakingSegment(0, braking.braking) < 0) { + mStatsApi->logError(kPwleConstructionFailError); + ALOGE("%s: #%u: braking: Failed to construct for type %d", __func__, c, + braking.braking); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } incrementIndex(&segmentIdx); - if (constructBrakingSegment(ch, braking.duration, braking.braking) < 0) { + if (ch.constructBrakingSegment(braking.duration, braking.braking) < 0) { + mStatsApi->logError(kPwleConstructionFailError); + ALOGE("%s: #%u: braking: Failed to construct for type %d with duration %d", + __func__, c, braking.braking, braking.duration); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } incrementIndex(&segmentIdx); @@ -1003,31 +1390,49 @@ ndk::ScopedAStatus Vibrator::composePwle(const std::vector<PrimitivePwle> &compo } if (segmentIdx > COMPOSE_PWLE_SIZE_MAX_DEFAULT) { + mStatsApi->logError(kPwleConstructionFailError); ALOGE("Too many PrimitivePwle section!"); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } + + c++; } - dspmem_chunk_flush(ch); + ch.flush(); /* Update wlength */ totalDuration += MAX_COLD_START_LATENCY_MS; if (totalDuration > 0x7FFFF) { + mStatsApi->logError(kPwleConstructionFailError); ALOGE("Total duration is too long (%d)!", totalDuration); return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); + } else { + mFfEffects[WAVEFORM_PWLE].replay.length = totalDuration; + } + + if (ch.updateWLength(totalDuration) < 0) { + mStatsApi->logError(kPwleConstructionFailError); + ALOGE("%s: Failed to update the waveform length length", __func__); + return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); } - updateWLength(ch, totalDuration); /* Update nsections */ - updateNSection(ch, segmentIdx); + if (ch.updateNSection(segmentIdx) < 0) { + mStatsApi->logError(kPwleConstructionFailError); + ALOGE("%s: Failed to update the section count", __func__); + return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); + } - return performEffect(0 /*ignored*/, 0 /*ignored*/, ch, callback); + return performEffect(WAVEFORM_MAX_INDEX /*ignored*/, VOLTAGE_SCALE_MAX /*ignored*/, &ch, + callback); } bool Vibrator::isUnderExternalControl() { + HAPTICS_TRACE("isUnderExternalControl()"); return mIsUnderExternalControl; } binder_status_t Vibrator::dump(int fd, const char **args, uint32_t numArgs) { + HAPTICS_TRACE("dump(fd:%d, args, numArgs:%u)", fd, numArgs); if (fd < 0) { ALOGE("Called debug() with invalid fd."); return STATUS_OK; @@ -1082,86 +1487,44 @@ binder_status_t Vibrator::dump(int fd, const char **args, uint32_t numArgs) { mHwCal->debug(fd); + dprintf(fd, "Capo Info\n"); + if (mContextListener) { + dprintf(fd, "Capo ID: 0x%x\n", (uint32_t)(mContextListener->getNanoppAppId())); + dprintf(fd, "Capo State: %d\n", mContextListener->getCarriedPosition()); + } + + mStatsApi->debug(fd); + fsync(fd); return STATUS_OK; } -bool Vibrator::findHapticAlsaDevice(int *card, int *device) { - std::string line; - std::ifstream myfile(PROC_SND_PCM); - if (myfile.is_open()) { - while (getline(myfile, line)) { - if (line.find(HAPTIC_PCM_DEVICE_SYMBOL) != std::string::npos) { - std::stringstream ss(line); - std::string currentToken; - std::getline(ss, currentToken, ':'); - sscanf(currentToken.c_str(), "%d-%d", card, device); - return true; - } - } - myfile.close(); - } else { - ALOGE("Failed to read file: %s", PROC_SND_PCM); - } - return false; -} - bool Vibrator::hasHapticAlsaDevice() { + HAPTICS_TRACE("hasHapticAlsaDevice()"); // We need to call findHapticAlsaDevice once only. Calling in the // constructor is too early in the boot process and the pcm file contents // are empty. Hence we make the call here once only right before we need to. - static bool configHapticAlsaDeviceDone = false; - if (!configHapticAlsaDeviceDone) { - if (findHapticAlsaDevice(&mCard, &mDevice)) { + if (!mConfigHapticAlsaDeviceDone) { + if (mHwApi->getHapticAlsaDevice(&mCard, &mDevice)) { mHasHapticAlsaDevice = true; - configHapticAlsaDeviceDone = true; + mConfigHapticAlsaDeviceDone = true; } else { + mStatsApi->logError(kAlsaFailError); ALOGE("Haptic ALSA device not supported"); } - } - return mHasHapticAlsaDevice; -} - -bool Vibrator::enableHapticPcmAmp(struct pcm **haptic_pcm, bool enable, int card, int device) { - int ret = 0; - - if (enable) { - *haptic_pcm = pcm_open(card, device, PCM_OUT, &haptic_nohost_config); - if (!pcm_is_ready(*haptic_pcm)) { - ALOGE("cannot open pcm_out driver: %s", pcm_get_error(*haptic_pcm)); - goto fail; - } - - ret = pcm_prepare(*haptic_pcm); - if (ret < 0) { - ALOGE("cannot prepare haptic_pcm: %s", pcm_get_error(*haptic_pcm)); - goto fail; - } - - ret = pcm_start(*haptic_pcm); - if (ret < 0) { - ALOGE("cannot start haptic_pcm: %s", pcm_get_error(*haptic_pcm)); - goto fail; - } - - return true; } else { - if (*haptic_pcm) { - pcm_close(*haptic_pcm); - *haptic_pcm = NULL; - } - return true; + ALOGD("Haptic ALSA device configuration done."); } - -fail: - pcm_close(*haptic_pcm); - *haptic_pcm = NULL; - return false; + return mHasHapticAlsaDevice; } ndk::ScopedAStatus Vibrator::getSimpleDetails(Effect effect, EffectStrength strength, uint32_t *outEffectIndex, uint32_t *outTimeMs, uint32_t *outVolLevel) { + HAPTICS_TRACE( + "getSimpleDetails(effect:%s, strength:%s, outEffectIndex, outTimeMs" + ", outVolLevel)", + toString(effect).c_str(), toString(strength).c_str()); uint32_t effectIndex; uint32_t timeMs; float intensity; @@ -1177,6 +1540,7 @@ ndk::ScopedAStatus Vibrator::getSimpleDetails(Effect effect, EffectStrength stre intensity = 1.0f; break; default: + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } @@ -1198,6 +1562,7 @@ ndk::ScopedAStatus Vibrator::getSimpleDetails(Effect effect, EffectStrength stre intensity *= 1.0f; break; default: + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } @@ -1211,7 +1576,9 @@ ndk::ScopedAStatus Vibrator::getSimpleDetails(Effect effect, EffectStrength stre } ndk::ScopedAStatus Vibrator::getCompoundDetails(Effect effect, EffectStrength strength, - uint32_t *outTimeMs, dspmem_chunk *outCh) { + uint32_t *outTimeMs, DspMemChunk *outCh) { + HAPTICS_TRACE("getCompoundDetails(effect:%s, strength:%s, outTimeMs, outCh)", + toString(effect).c_str(), toString(strength).c_str()); ndk::ScopedAStatus status; uint32_t timeMs = 0; uint32_t thisEffectIndex; @@ -1219,55 +1586,54 @@ ndk::ScopedAStatus Vibrator::getCompoundDetails(Effect effect, EffectStrength st uint32_t thisVolLevel; switch (effect) { case Effect::DOUBLE_CLICK: - dspmem_chunk_write(outCh, 8, 0); /* Padding */ - dspmem_chunk_write(outCh, 8, 2); /* nsections */ - dspmem_chunk_write(outCh, 8, 0); /* repeat */ - status = getSimpleDetails(Effect::CLICK, strength, &thisEffectIndex, &thisTimeMs, &thisVolLevel); if (!status.isOk()) { + mStatsApi->logError(kBadEffectError); return status; } timeMs += thisTimeMs; - - dspmem_chunk_write(outCh, 8, (uint8_t)(0xFF & thisVolLevel)); /* amplitude */ - dspmem_chunk_write(outCh, 8, (uint8_t)(0xFF & thisEffectIndex)); /* index */ - dspmem_chunk_write(outCh, 8, 0); /* repeat */ - dspmem_chunk_write(outCh, 8, 0); /* flags */ - dspmem_chunk_write(outCh, 16, - (uint16_t)(0xFFFF & WAVEFORM_DOUBLE_CLICK_SILENCE_MS)); /* delay */ + outCh->constructComposeSegment(thisVolLevel, thisEffectIndex, 0 /*repeat*/, 0 /*flags*/, + WAVEFORM_DOUBLE_CLICK_SILENCE_MS); timeMs += WAVEFORM_DOUBLE_CLICK_SILENCE_MS + MAX_PAUSE_TIMING_ERROR_MS; status = getSimpleDetails(Effect::HEAVY_CLICK, strength, &thisEffectIndex, &thisTimeMs, &thisVolLevel); if (!status.isOk()) { + mStatsApi->logError(kBadEffectError); return status; } timeMs += thisTimeMs; - dspmem_chunk_write(outCh, 8, (uint8_t)(0xFF & thisVolLevel)); /* amplitude */ - dspmem_chunk_write(outCh, 8, (uint8_t)(0xFF & thisEffectIndex)); /* index */ - dspmem_chunk_write(outCh, 8, 0); /* repeat */ - dspmem_chunk_write(outCh, 8, 0); /* flags */ - dspmem_chunk_write(outCh, 16, 0); /* delay */ - dspmem_chunk_flush(outCh); + outCh->constructComposeSegment(thisVolLevel, thisEffectIndex, 0 /*repeat*/, 0 /*flags*/, + 0 /*delay*/); + outCh->flush(); + if (outCh->updateNSection(2) < 0) { + mStatsApi->logError(kComposeFailError); + ALOGE("%s: Failed to update the section count", __func__); + return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); + } break; default: + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } *outTimeMs = timeMs; + mFfEffects[WAVEFORM_COMPOSE].replay.length = static_cast<uint16_t>(timeMs); return ndk::ScopedAStatus::ok(); } ndk::ScopedAStatus Vibrator::getPrimitiveDetails(CompositePrimitive primitive, uint32_t *outEffectIndex) { + HAPTICS_TRACE("getPrimitiveDetails(primitive:%s, outEffectIndex)", toString(primitive).c_str()); uint32_t effectIndex; uint32_t primitiveBit = 1 << int32_t(primitive); if ((primitiveBit & mSupportedPrimitivesBits) == 0x0) { + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } @@ -1299,6 +1665,7 @@ ndk::ScopedAStatus Vibrator::getPrimitiveDetails(CompositePrimitive primitive, effectIndex = WAVEFORM_LOW_TICK_INDEX; break; default: + mStatsApi->logError(kUnsupportedOpError); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); } @@ -1307,83 +1674,16 @@ ndk::ScopedAStatus Vibrator::getPrimitiveDetails(CompositePrimitive primitive, return ndk::ScopedAStatus::ok(); } -ndk::ScopedAStatus Vibrator::uploadOwtEffect(uint8_t *owtData, uint32_t numBytes, - uint32_t *outEffectIndex) { - if (owtData == nullptr) { - ALOGE("Invalid waveform bank"); - return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); - } - - bool isPwle = (*reinterpret_cast<uint16_t *>(owtData) != 0x0000); - WaveformIndex targetId = isPwle ? WAVEFORM_PWLE : WAVEFORM_COMPOSE; - - uint32_t freeBytes; - mHwApi->getOwtFreeSpace(&freeBytes); - if (numBytes > freeBytes) { - ALOGE("Effect %d length: %d > %d!", targetId, numBytes, freeBytes); - return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT); - } - - mFfEffects[targetId].u.periodic.custom_len = numBytes / sizeof(uint16_t); - delete[](mFfEffects[targetId].u.periodic.custom_data); - mFfEffects[targetId].u.periodic.custom_data = - new int16_t[mFfEffects[targetId].u.periodic.custom_len]{0x0000}; - if (mFfEffects[targetId].u.periodic.custom_data == nullptr) { - ALOGE("Failed to allocate memory for custom data\n"); - return ndk::ScopedAStatus::fromExceptionCode(EX_NULL_POINTER); - } - memcpy(mFfEffects[targetId].u.periodic.custom_data, owtData, numBytes); - - /* - * Erase the created OWT waveform. If no error, the HAL, ff-core and haptics driver effect lists - * are properly aligned. Hence, proceed to add a new effect to play. If failed, scanarios are as - * follows: - * 1. ENOMEM 12 Out of memory: - * Driver effect list is empty while HAL and ff-cores' are not. - * Effect editing can add the OWT effect to driver while keep the original effect ID. - * 2. EACCES 13 Permission denied: - * Effect was created by others or previous HAL instance (HAL got restarted). - * No way to erase old effects managed by ff-core and need reboot. - */ - bool isCreated = (mFfEffects[targetId].id != -1); - if (isCreated && ioctl(mInputFd, EVIOCRMFF, targetId) < 0) { - ALOGW("Failed to erase effect %d(%d) (%d): %s", targetId, mFfEffects[targetId].id, errno, - strerror(errno)); - mFfEffects[targetId].id = targetId; - - /* Edit the current effect to see if we can make effect lists aligned. */ - if (ioctl(mInputFd, EVIOCSFF, &mFfEffects[targetId]) < 0) { - /* If it is EINVAL 22 Invalid argument, the owner is not the current HAL instance. */ - ALOGE("Failed to upload effect %d (%d): %s", targetId, errno, strerror(errno)); - delete[](mFfEffects[targetId].u.periodic.custom_data); - return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); - } else { - ALOGV("Successful to overwrite effect %d.", targetId); - } - } else { - /* Create a new OWT waveform to update the PWLE or composite effect. */ - mFfEffects[targetId].id = -1; - if (ioctl(mInputFd, EVIOCSFF, &mFfEffects[targetId]) < 0) { - ALOGE("Failed to upload effect %d (%d): %s", targetId, errno, strerror(errno)); - delete[](mFfEffects[targetId].u.periodic.custom_data); - return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE); - } - } - - *outEffectIndex = mFfEffects[targetId].id; - - return ndk::ScopedAStatus::ok(); -} - ndk::ScopedAStatus Vibrator::performEffect(Effect effect, EffectStrength strength, const std::shared_ptr<IVibratorCallback> &callback, int32_t *outTimeMs) { + HAPTICS_TRACE("performEffect(effect:%s, strength:%s, callback, outTimeMs)", + toString(effect).c_str(), toString(strength).c_str()); ndk::ScopedAStatus status; uint32_t effectIndex; uint32_t timeMs = 0; uint32_t volLevel; - dspmem_chunk *ch = nullptr; - + std::optional<DspMemChunk> maybeCh; switch (effect) { case Effect::TEXTURE_TICK: // fall-through @@ -1395,47 +1695,62 @@ ndk::ScopedAStatus Vibrator::performEffect(Effect effect, EffectStrength strengt status = getSimpleDetails(effect, strength, &effectIndex, &timeMs, &volLevel); break; case Effect::DOUBLE_CLICK: - ch = dspmem_chunk_create(new uint8_t[FF_CUSTOM_DATA_LEN_MAX_COMP]{0x00}, - FF_CUSTOM_DATA_LEN_MAX_COMP); - status = getCompoundDetails(effect, strength, &timeMs, ch); + maybeCh.emplace(WAVEFORM_COMPOSE, FF_CUSTOM_DATA_LEN_MAX_COMP); + status = getCompoundDetails(effect, strength, &timeMs, &*maybeCh); + volLevel = VOLTAGE_SCALE_MAX; break; default: + mStatsApi->logError(kUnsupportedOpError); status = ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION); break; } - if (!status.isOk()) { - goto exit; + if (status.isOk()) { + DspMemChunk *ch = maybeCh ? &*maybeCh : nullptr; + status = performEffect(effectIndex, volLevel, ch, callback); } - status = performEffect(static_cast<uint16_t>(effectIndex), volLevel, ch, callback); - -exit: *outTimeMs = timeMs; return status; } ndk::ScopedAStatus Vibrator::performEffect(uint32_t effectIndex, uint32_t volLevel, - dspmem_chunk *ch, + const DspMemChunk *ch, const std::shared_ptr<IVibratorCallback> &callback) { - if (ch) { - ndk::ScopedAStatus status = uploadOwtEffect(ch->head, dspmem_chunk_bytes(ch), &effectIndex); - delete ch; - if (!status.isOk()) { - return status; - } - setEffectAmplitude(VOLTAGE_SCALE_MAX, VOLTAGE_SCALE_MAX); - } else { - setEffectAmplitude(volLevel, VOLTAGE_SCALE_MAX); - } + HAPTICS_TRACE("performEffect(effectIndex:%u, volLevel:%u, ch, callback)", effectIndex, + volLevel); + setEffectAmplitude(volLevel, VOLTAGE_SCALE_MAX, false); - return on(MAX_TIME_MS, effectIndex, callback); + return on(MAX_TIME_MS, effectIndex, ch, callback); } void Vibrator::waitForComplete(std::shared_ptr<IVibratorCallback> &&callback) { + HAPTICS_TRACE("waitForComplete(callback)"); + if (!mHwApi->pollVibeState(VIBE_STATE_HAPTIC, POLLING_TIMEOUT)) { - ALOGE("Fail to get state \"Haptic\""); + ALOGW("Failed to get state \"Haptic\""); } + ATRACE_BEGIN("Vibrating"); mHwApi->pollVibeState(VIBE_STATE_STOPPED); + ATRACE_END(); + + const std::scoped_lock<std::mutex> lock(mActiveId_mutex); + uint32_t effectCount = WAVEFORM_MAX_PHYSICAL_INDEX; + if ((mActiveId >= WAVEFORM_MAX_PHYSICAL_INDEX) && + (!mHwApi->eraseOwtEffect(mActiveId, &mFfEffects))) { + mStatsApi->logError(kHwApiError); + ALOGE("Failed to clean up the composed effect %d", mActiveId); + } else { + ALOGD("waitForComplete: Vibrator is already off"); + } + mHwApi->getEffectCount(&effectCount); + // Do waveform number checking + if ((effectCount > WAVEFORM_MAX_PHYSICAL_INDEX) && + (!mHwApi->eraseOwtEffect(WAVEFORM_MAX_INDEX, &mFfEffects))) { + mStatsApi->logError(kHwApiError); + ALOGE("Failed to forcibly clean up all composed effect"); + } + + mActiveId = -1; if (callback) { auto ret = callback->onComplete(); @@ -1446,6 +1761,8 @@ void Vibrator::waitForComplete(std::shared_ptr<IVibratorCallback> &&callback) { } uint32_t Vibrator::intensityToVolLevel(float intensity, uint32_t effectIndex) { + HAPTICS_TRACE("intensityToVolLevel(intensity:%f, effectIndex:%u)", intensity, effectIndex); + uint32_t volLevel; auto calc = [](float intst, std::array<uint32_t, 2> v) -> uint32_t { return std::lround(intst * (v[1] - v[0])) + v[0]; diff --git a/vibrator/cs40l26/Vibrator.h b/vibrator/cs40l26/Vibrator.h index a183cac0..0c540682 100644 --- a/vibrator/cs40l26/Vibrator.h +++ b/vibrator/cs40l26/Vibrator.h @@ -16,18 +16,28 @@ #pragma once #include <aidl/android/hardware/vibrator/BnVibrator.h> +#include <android-base/stringprintf.h> #include <android-base/unique_fd.h> +#include <linux/input.h> #include <tinyalsa/asoundlib.h> #include <array> +#include <chrono> +#include <ctime> #include <fstream> #include <future> +#include "CapoDetector.h" + +using CapoDetector = android::chre::CapoDetector; + namespace aidl { namespace android { namespace hardware { namespace vibrator { +using ::android::base::StringPrintf; + class Vibrator : public BnVibrator { public: // APIs for interfacing with the kernel driver. @@ -60,6 +70,42 @@ class Vibrator : public BnVibrator { virtual bool setRedcCompEnable(bool value) = 0; // Stores the minumun delay time between playback and stop effects. virtual bool setMinOnOffInterval(uint32_t value) = 0; + // Determine the /dev and /sys paths for input force-feedback control. + virtual bool initFF() = 0; + // Gets the scaling factor for contextual haptic events. + virtual uint32_t getContextScale() = 0; + // Gets the enable status for contextual haptic events. + virtual bool getContextEnable() = 0; + // Gets the settling time for contextual haptic events. + // This will allow the device to stay face up for the duration given, + // even if InMotion events were detected. + virtual uint32_t getContextSettlingTime() = 0; + // Gets the cooldown time for contextual haptic events. + // This is used to avoid changing the scale of close playback events. + virtual uint32_t getContextCooldownTime() = 0; + // Checks the enable status for contextual haptics fade feature. When enabled + // this feature will cause the scaling factor to fade back up to max over + // the setting time set, instead of instantaneously changing it back to max. + virtual bool getContextFadeEnable() = 0; + // Indicates the number of 0.125-dB steps of attenuation to apply to + // waveforms triggered in response to vibration calls from the + // Android vibrator HAL. + virtual bool setFFGain(uint16_t value) = 0; + // Create/modify custom effects for all physical waveforms. + virtual bool setFFEffect(struct ff_effect *effect, uint16_t timeoutMs) = 0; + // Activates/deactivates the effect index after setFFGain() and setFFEffect(). + virtual bool setFFPlay(int8_t index, bool value) = 0; + // Get the Alsa device for the audio coupled haptics effect + virtual bool getHapticAlsaDevice(int *card, int *device) = 0; + // Set haptics PCM amplifier before triggering audio haptics feature + virtual bool setHapticPcmAmp(struct pcm **haptic_pcm, bool enable, int card, + int device) = 0; + // Set OWT waveform for compose or compose PWLE request + virtual bool uploadOwtEffect(const uint8_t *owtData, const uint32_t numBytes, + struct ff_effect *effect, uint32_t *outEffectIndex, + int *status) = 0; + // Erase OWT waveform + virtual bool eraseOwtEffect(int8_t effectIndex, std::vector<ff_effect> *effect) = 0; // Emit diagnostic information to the given file. virtual void debug(int fd) = 0; }; @@ -81,6 +127,10 @@ class Vibrator : public BnVibrator { virtual bool getQ(std::string *value) = 0; // Obtains frequency shift for long vibrations. virtual bool getLongFrequencyShift(int32_t *value) = 0; + // Obtains device mass for calculating the bandwidth amplitude map + virtual bool getDeviceMass(float *value) = 0; + // Obtains loc coeff for calculating the bandwidth amplitude map + virtual bool getLocCoeff(float *value) = 0; // Obtains the v0/v1(min/max) voltage levels to be applied for // tick/click/long in units of 1%. virtual bool getTickVolLevels(std::array<uint32_t, 2> *value) = 0; @@ -90,12 +140,35 @@ class Vibrator : public BnVibrator { virtual bool isChirpEnabled() = 0; // Obtains the supported primitive effects. virtual bool getSupportedPrimitives(uint32_t *value) = 0; + // Checks if the f0 compensation feature needs to be enabled. + virtual bool isF0CompEnabled() = 0; + // Checks if the redc compensation feature needs to be enabled. + virtual bool isRedcCompEnabled() = 0; + // Emit diagnostic information to the given file. + virtual void debug(int fd) = 0; + }; + + // APIs for logging data to statistics backend + class StatsApi { + public: + virtual ~StatsApi() = default; + // Increment count for effect + virtual bool logPrimitive(uint16_t effectIndex) = 0; + // Increment count for long/short waveform and duration bucket + virtual bool logWaveform(uint16_t effectIndex, int32_t duration) = 0; + // Increment count for error + virtual bool logError(uint16_t errorIndex) = 0; + // Start new latency measurement + virtual bool logLatencyStart(uint16_t latencyIndex) = 0; + // Finish latency measurement and update latency statistics with result + virtual bool logLatencyEnd() = 0; // Emit diagnostic information to the given file. virtual void debug(int fd) = 0; }; public: - Vibrator(std::unique_ptr<HwApi> hwapi, std::unique_ptr<HwCal> hwcal); + Vibrator(std::unique_ptr<HwApi> hwapi, std::unique_ptr<HwCal> hwcal, + std::unique_ptr<StatsApi> statsapi); ndk::ScopedAStatus getCapabilities(int32_t *_aidl_return) override; ndk::ScopedAStatus off() override; @@ -131,10 +204,10 @@ class Vibrator : public BnVibrator { binder_status_t dump(int fd, const char **args, uint32_t numArgs) override; private: - ndk::ScopedAStatus on(uint32_t timeoutMs, uint32_t effectIndex, + ndk::ScopedAStatus on(uint32_t timeoutMs, uint32_t effectIndex, const class DspMemChunk *ch, const std::shared_ptr<IVibratorCallback> &callback); // set 'amplitude' based on an arbitrary scale determined by 'maximum' - ndk::ScopedAStatus setEffectAmplitude(float amplitude, float maximum); + ndk::ScopedAStatus setEffectAmplitude(float amplitude, float maximum, bool scalable); ndk::ScopedAStatus setGlobalAmplitude(bool set); // 'simple' effects are those precompiled and loaded into the controller ndk::ScopedAStatus getSimpleDetails(Effect effect, EffectStrength strength, @@ -142,15 +215,13 @@ class Vibrator : public BnVibrator { uint32_t *outVolLevel); // 'compound' effects are those composed by stringing multiple 'simple' effects ndk::ScopedAStatus getCompoundDetails(Effect effect, EffectStrength strength, - uint32_t *outTimeMs, struct dspmem_chunk *outCh); + uint32_t *outTimeMs, class DspMemChunk *outCh); ndk::ScopedAStatus getPrimitiveDetails(CompositePrimitive primitive, uint32_t *outEffectIndex); - ndk::ScopedAStatus uploadOwtEffect(uint8_t *owtData, uint32_t num_bytes, - uint32_t *outEffectIndex); ndk::ScopedAStatus performEffect(Effect effect, EffectStrength strength, const std::shared_ptr<IVibratorCallback> &callback, int32_t *outTimeMs); ndk::ScopedAStatus performEffect(uint32_t effectIndex, uint32_t volLevel, - struct dspmem_chunk *ch, + const class DspMemChunk *ch, const std::shared_ptr<IVibratorCallback> &callback); ndk::ScopedAStatus setPwle(const std::string &pwleQueue); bool isUnderExternalControl(); @@ -159,26 +230,45 @@ class Vibrator : public BnVibrator { bool findHapticAlsaDevice(int *card, int *device); bool hasHapticAlsaDevice(); bool enableHapticPcmAmp(struct pcm **haptic_pcm, bool enable, int card, int device); + void createPwleMaxLevelLimitMap(); + void createBandwidthAmplitudeMap(); + uint16_t amplitudeToScale(float amplitude, float maximum, bool scalable); + void updateContext(); std::unique_ptr<HwApi> mHwApi; std::unique_ptr<HwCal> mHwCal; + std::unique_ptr<StatsApi> mStatsApi; uint32_t mF0Offset; std::array<uint32_t, 2> mTickEffectVol; std::array<uint32_t, 2> mClickEffectVol; std::array<uint32_t, 2> mLongEffectVol; + std::vector<ff_effect> mFfEffects; std::vector<uint32_t> mEffectDurations; + std::vector<std::vector<int16_t>> mEffectCustomData; std::future<void> mAsyncHandle; - ::android::base::unique_fd mInputFd; int8_t mActiveId{-1}; struct pcm *mHapticPcm; int mCard; int mDevice; - bool mHasHapticAlsaDevice; + bool mHasHapticAlsaDevice{false}; bool mIsUnderExternalControl; float mLongEffectScale = 1.0; bool mIsChirpEnabled; uint32_t mSupportedPrimitivesBits = 0x0; + float mRedc{0}; + float mResonantFrequency{0}; std::vector<CompositePrimitive> mSupportedPrimitives; + bool mConfigHapticAlsaDeviceDone{false}; + std::vector<float> mBandwidthAmplitudeMap{}; + bool mCreateBandwidthAmplitudeMapDone{false}; + uint32_t mScaleTime; + bool mFadeEnable; + uint32_t mScalingFactor; + uint32_t mScaleCooldown; + bool mContextEnable; + uint32_t mLastEffectPlayedTime = 0; + float mLastPlayedScale = 0; + sp<CapoDetector> mContextListener; }; } // namespace vibrator diff --git a/vibrator/cs40l26/android.hardware.vibrator-service.cs40l26-dual.rc b/vibrator/cs40l26/android.hardware.vibrator-service.cs40l26-dual.rc index 5e8aac7f..a2d4706b 100644 --- a/vibrator/cs40l26/android.hardware.vibrator-service.cs40l26-dual.rc +++ b/vibrator/cs40l26/android.hardware.vibrator-service.cs40l26-dual.rc @@ -1,25 +1,3 @@ -on boot && property:vendor.all.modules.ready=1 - wait /sys/bus/i2c/devices/i2c-cs40l26a-dual/calibration/redc_cal_time_ms - - mkdir /mnt/vendor/persist/haptics 0770 system system - chmod 770 /mnt/vendor/persist/haptics - chmod 440 /mnt/vendor/persist/haptics/cs40l26_dual.cal - chown system system /mnt/vendor/persist/haptics - chown system system /mnt/vendor/persist/haptics/cs40l26_dual.cal - - chown system system /sys/bus/i2c/devices/i2c-cs40l26a-dual/calibration/f0_stored - chown system system /sys/bus/i2c/devices/i2c-cs40l26a-dual/calibration/q_stored - chown system system /sys/bus/i2c/devices/i2c-cs40l26a-dual/calibration/redc_stored - chown system system /sys/bus/i2c/devices/i2c-cs40l26a-dual/default/vibe_state - chown system system /sys/bus/i2c/devices/i2c-cs40l26a-dual/default/num_waves - chown system system /sys/bus/i2c/devices/i2c-cs40l26a-dual/default/f0_offset - chown system system /sys/bus/i2c/devices/i2c-cs40l26a-dual/default/owt_free_space - chown system system /sys/bus/i2c/devices/i2c-cs40l26a-dual/default/f0_comp_enable - chown system system /sys/bus/i2c/devices/i2c-cs40l26a-dual/default/redc_comp_enable - chown system system /sys/bus/i2c/devices/i2c-cs40l26a-dual/default/delay_before_stop_playback_us - - enable vendor.vibrator.cs40l26-dual - service vendor.vibrator.cs40l26-dual /vendor/bin/hw/android.hardware.vibrator-service.cs40l26-dual class hal user system @@ -29,7 +7,6 @@ service vendor.vibrator.cs40l26-dual /vendor/bin/hw/android.hardware.vibrator-se setenv PROPERTY_PREFIX ro.vendor.vibrator.hal. setenv CALIBRATION_FILEPATH /mnt/vendor/persist/haptics/cs40l26_dual.cal - setenv HWAPI_PATH_PREFIX /sys/bus/i2c/devices/i2c-cs40l26a-dual/ setenv HWAPI_DEBUG_PATHS " calibration/f0_stored calibration/redc_stored @@ -43,4 +20,6 @@ service vendor.vibrator.cs40l26-dual /vendor/bin/hw/android.hardware.vibrator-se default/delay_before_stop_playback_us " + setenv STATS_INSTANCE default + disabled diff --git a/vibrator/cs40l26/android.hardware.vibrator-service.cs40l26.rc b/vibrator/cs40l26/android.hardware.vibrator-service.cs40l26.rc index 89d0eb7f..8c9e2c2d 100644 --- a/vibrator/cs40l26/android.hardware.vibrator-service.cs40l26.rc +++ b/vibrator/cs40l26/android.hardware.vibrator-service.cs40l26.rc @@ -1,35 +1,12 @@ -on boot && property:vendor.all.modules.ready=1 - wait /sys/bus/i2c/devices/i2c-cs40l26a/calibration/redc_cal_time_ms - - mkdir /mnt/vendor/persist/haptics 0770 system system - chmod 770 /mnt/vendor/persist/haptics - chmod 440 /mnt/vendor/persist/haptics/cs40l26.cal - chown system system /mnt/vendor/persist/haptics - chown system system /mnt/vendor/persist/haptics/cs40l26.cal - - chown system system /sys/bus/i2c/devices/i2c-cs40l26a/calibration/f0_stored - chown system system /sys/bus/i2c/devices/i2c-cs40l26a/calibration/q_stored - chown system system /sys/bus/i2c/devices/i2c-cs40l26a/calibration/redc_stored - chown system system /sys/bus/i2c/devices/i2c-cs40l26a/default/vibe_state - chown system system /sys/bus/i2c/devices/i2c-cs40l26a/default/num_waves - chown system system /sys/bus/i2c/devices/i2c-cs40l26a/default/f0_offset - chown system system /sys/bus/i2c/devices/i2c-cs40l26a/default/owt_free_space - chown system system /sys/bus/i2c/devices/i2c-cs40l26a/default/f0_comp_enable - chown system system /sys/bus/i2c/devices/i2c-cs40l26a/default/redc_comp_enable - chown system system /sys/bus/i2c/devices/i2c-cs40l26a/default/delay_before_stop_playback_us - - enable vendor.vibrator.cs40l26 - service vendor.vibrator.cs40l26 /vendor/bin/hw/android.hardware.vibrator-service.cs40l26 class hal user system - group system input + group system input context_hub setenv INPUT_EVENT_NAME cs40l26_input setenv PROPERTY_PREFIX ro.vendor.vibrator.hal. setenv CALIBRATION_FILEPATH /mnt/vendor/persist/haptics/cs40l26.cal - setenv HWAPI_PATH_PREFIX /sys/bus/i2c/devices/i2c-cs40l26a/ setenv HWAPI_DEBUG_PATHS " calibration/f0_stored calibration/redc_stored @@ -43,4 +20,13 @@ service vendor.vibrator.cs40l26 /vendor/bin/hw/android.hardware.vibrator-service default/delay_before_stop_playback_us " + setenv STATS_INSTANCE default + disabled + +# Route vibrator.adaptive_haptics.enabled to persist +on property:vibrator.adaptive_haptics.enabled=0 + setprop persist.vendor.vibrator.hal.context.enable false + +on property:vibrator.adaptive_haptics.enabled=1 + setprop persist.vendor.vibrator.hal.context.enable true diff --git a/vibrator/cs40l26/apex/Android.bp b/vibrator/cs40l26/apex/Android.bp new file mode 100644 index 00000000..dea90ed6 --- /dev/null +++ b/vibrator/cs40l26/apex/Android.bp @@ -0,0 +1,63 @@ +// Copyright (C) 2022 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. + +package { + default_applicable_licenses: ["Android-Apache-2.0"], +} + +apex_key { + name: "com.google.pixel.vibrator.hal.key", + public_key: "com.google.pixel.vibrator.hal.avbpubkey", + private_key: "com.google.pixel.vibrator.hal.pem", +} + +android_app_certificate { + name: "com.google.pixel.vibrator.hal.certificate", + certificate: "com.google.pixel.vibrator.hal", +} + +genrule { + name: "gen-android.hardware.vibrator-service.cs40l26.rc", + srcs: [":android.hardware.vibrator-service.cs40l26.rc"], + out: ["android.hardware.vibrator-service.cs40l26.rc"], + cmd: "sed -E 's/\\/vendor\\/bin/\\/apex\\/com.google.pixel.vibrator.hal\\/bin/' $(in) > $(out)", +} + +prebuilt_etc { + name: "apex-android.hardware.vibrator-service.cs40l26.rc", + src: ":gen-android.hardware.vibrator-service.cs40l26.rc", + installable: false, +} + +apex { + name: "com.google.pixel.vibrator.hal", + manifest: "apex_manifest.json", + file_contexts: "file_contexts", // Default, please edit, see go/android-apex-howto + key: "com.google.pixel.vibrator.hal.key", + certificate: ":com.google.pixel.vibrator.hal.certificate", + vintf_fragments: [ + ":android.hardware.vibrator-service.cs40l26.xml", + ], + use_vndk_as_stable: true, + // Install the apex in /vendor/apex + soc_specific: true, + updatable: false, + binaries: [ + "android.hardware.vibrator-service.cs40l26", + ], + prebuilts: [ + "apex-android.hardware.vibrator-service.cs40l26.rc", + ], + overrides: ["android.hardware.vibrator-service.cs40l26"], +} diff --git a/vibrator/cs40l26/apex/apex_manifest.json b/vibrator/cs40l26/apex/apex_manifest.json new file mode 100644 index 00000000..cbdc876c --- /dev/null +++ b/vibrator/cs40l26/apex/apex_manifest.json @@ -0,0 +1,4 @@ +{ + "name": "com.google.pixel.vibrator.hal", + "version": 1 +} diff --git a/vibrator/cs40l26/apex/com.google.pixel.vibrator.hal.avbpubkey b/vibrator/cs40l26/apex/com.google.pixel.vibrator.hal.avbpubkey Binary files differnew file mode 100644 index 00000000..46b6769f --- /dev/null +++ b/vibrator/cs40l26/apex/com.google.pixel.vibrator.hal.avbpubkey diff --git a/vibrator/cs40l26/apex/com.google.pixel.vibrator.hal.pem b/vibrator/cs40l26/apex/com.google.pixel.vibrator.hal.pem new file mode 100644 index 00000000..595322ac --- /dev/null +++ b/vibrator/cs40l26/apex/com.google.pixel.vibrator.hal.pem @@ -0,0 +1,52 @@ +-----BEGIN PRIVATE KEY----- +MIIJQgIBADANBgkqhkiG9w0BAQEFAASCCSwwggkoAgEAAoICAQCy3WtYEB2dj08K +NLVgyORlpKBK2CqcUmQU5VOlVEnp9Ek8KPvH0KxlbTfYvjAatqC0h312NdUN1JX8 +pQLj7MEzQfvZkJYUlZeK/exqUrBQ8mvR0vzSoNg3HMBJWAOG0sbc3A4ZWXVxreMB +W+Yg2Jm1cXAijf1TmJWTk3lbZ4Cxh4G6Moj4xeQ3Tte+8oXKYTnp2Jh+ojelQI/F +E9uSkkyWGFdHAR8Wpu1a5uCD3Rol7YOy3Aw8FV1sUv/+rqNejzKkTlGUI5ABuUqu +jLyGdWnXUhJt4VUqnY+KyptY3KiQxR0oiGK0f3+hdpPBAm7gGu8HTt2psPAmnFs+ +DVvfiuYTHYN0nMr+GVCFwPNurBgv70IlViDA5y9yfRoMzZ6dKTBj1fiHqu1qcOUA +6r3WFjjTYmQqwrVJ4aKSR6zbn8UDiPpofiyfxiODJ+Wm7E8ozshdKyhtnjCvyxI/ +rNYmTF5DGIBY6Mi7+faV2JM0IjVgY5vDWIH0OF6Jc1NawfDmUsr8XQo/pOxGlyKU +8HTfC1uFLYR915q/9SrTSaazliXf5gWxAw9xMlkoGAxUnGHsuhHdiOG5bQb+OiBl +soiVP2IIPMGTRS5aUf7rdFFlc0I3q9Si+468C1qpTBTo2ddxFDvMaF8xsRkH7UYX +Qwh+RkakWHAVedAiFOszdMceYIReUwIDAQABAoICAAeeOgfmdwRyo2vfwjvmXCGS +IrudVY9Ff3q+W7lgC8Ss2wB2p5nWliK8+J+nVhArm1Bx46xiiMaahjrcLyShcFPs +QwhJfRyD7im4b/A4jmCCoSH7ydKrKoC9nXKVdSz+xdAhVT5lWrgZSMcr8IzElonH +ITIJK/MUCobeRWrY6TIzTDMWG1LEYIuuGxVIahD5FbwTT0drEriom8owJgfdNrYL +2lr6JFm7VilEsE2D3/m7XukblmMDiL004C9ePwB0U+e/Ac18u3glueJEuNp3N/Qf +GQ0+1CxI/EfUIkxLtag/PpZiQxkrkJzCND/VVTIy8EXpteb+bY2pCiyfgzxUEHSv +yhFtAqCdcB8q6uhFZvUvfUhKVUAgwTnlES06s7CrJQo56zblAVmYwyNLheiCooTQ +M3oRHuZrZDsdyo7UKAhn2gpT7w8/gOLFE4p00UVWVHF22+0NOhIojN0yA+y1b2Cw +/Sy/LE2U/wgemRDjgepekk5J+OfBPzHsFYP1r7m+WTru1YOTonmF4sUsM5f+5N2f +1v7FuHrgjCohrlInk6hzNISXzS022j1DyE92fNebP90Q72oEMAZOChVRP+HeIuZQ +ZNr8DddD+RiNqkA/m4+6IpOtbdKDXZOZWX5xFxkWbrV7e8cLbexHIdqVuovFC/aZ +77Np7yeAs0hox0FLHZsVAoIBAQC8LoY4hmye0Qmma1myEh9j3eIOWAsSSNjX9Aoh +/lF8lx+3F9eOQB9a6WZ+2wiLLIP/zrnlfa5xbNp1pV4rT7n1Zd3pB4g1YffXmb1Z +egEssor6wE54i6btWm7G2LvVfGNwWxUWYz3vYVAlVxtkeRug4+I+SidPgpmlfxdP +WJqzgbjPilOwZ4Tw4ue3jhHK6c3codJKULV5NVm4pLLqSpL1CEIOufZbxENplJ2C +daO2GDeOVXGp/1M4SrYidIbmPFXs5z3FupzGk9yNbQYg1q7RLRIYdhgztLA/jIcK +XE5PGPXwYGTsM1HljQgjqxwByd0BSj/nIRnPqtkyQFNi1h/dAoIBAQDzU1WB1zA6 +iJnAQp6AD3UMjgWXrARGFFn8w9mJ8nlArbiLqiBXDsQqOuFbM/UH8zjXD5Qn3atQ +kGT97PumxDznMPXtLo79MexZnRgfPAGsP7dhid8LKjaVVe0ME6LHuqLc668TkpxA +eQONuamyY9veeRriSqUjSQYOPss9ECTWxCACAh4EYVvg5nF0hLk7VtxUvqmKvBr0 +FNob7kDhUxEaBopuFh9oBBqBldbHf+O3++47EfwZFxXyzc/CquVOAc3tbb9C076N +W10VBgoF4lr/Z1/f9azJGn+Gr8hy1A3bSQRKHV2MKDiWp9C7PP/865nVCvLMgxRt +PWOsWVCVZKvvAoIBAAP0MkvDv0qC9+HwRX0xVkmB4vsMLIdg0nWPIhtevZWRk1AE +hzns7Pu7BbVKot5RvCBG1q8UufKWJ+zq4ZSlYzHdxxDbYKhGe6+jAlB7+MRYqATm +v39W59X63XL+IMw2hdxZfZLv2OBLuiRetSuiQ8tYnmtSoYrRIqtQhUvcf7uf0SND +M8j0E93/1oCL0qHh0bp+B+4ZzgZS8aSoiT3U/Ut6tfCbRard79CrF7gjAqKT1a7+ +6pl4zOXU5AjLS/5QbDnDDhA2gI7Hko3CKavM9vVcLhIngRCtDjr3l+rGz7pnutsn +G1e/KExbbz1YngkHlcYuKjOQBXvQiim9IkNkXl0CggEBAL5JyXEFDF56PWMxtiqH +7A2pc44tpBn6CHW35AQRb+m48b2niisLDTXJXjuo4lMZTrZBJKgYnsUeZxx9nD/K +76YNkAWwh3pS9HcQd7DViKlgGtVYsOlWVeFrlToAkSiJOJx0ZDJ2UWPKP5EyRReR +KH1PUErv/T0e+nFhgid63JRoRG/NoBPk36l+DfQFZ6aUQzKy+Hvap2mCdR+qr2qH +P7SOsOtuuZjqvJ/iwli6FyfnCWOAqRomB7Aea//dDf53QsgPL6ffWAHMFXs/gc8g +OfHKshu/USTkaB64kZXbaAq5i3U6idH2EmsfSgljpv3wchk9uqtdRzg27h/2qSJr +3FkCggEAFYAQ0gePuwRn2FVN5hoIxrDsExpKDOejGlB/y9+B5JNpOdKIgcUj/M2Y +sgEnlrApELwEduidPSyOV/cl6E3bDPAUrZVDF3boHjy5R3Akh3dpngH+IcQskfN4 +49eedBe0CAqU/WNA6OtEh0+CiSmhAuAkMmo0v9Q/6gYQBsPZ+IYnL/4zaeS/y2xn +mMxeS3eNxin62KxnomHGknRfqSO6kXL6NwfZbPMdJhDVmmowuPuUd2Fix2E0IpJB +AJQqJuAUpe7PF3Q+MobaIwRzQZXVmeBPAUJXDr/1p67gr4qDybJYvZAyJhXMztiq +vgJDLYQ0TdEWpv6trpA3s3hgFOx16g== +-----END PRIVATE KEY----- diff --git a/vibrator/cs40l26/apex/com.google.pixel.vibrator.hal.pk8 b/vibrator/cs40l26/apex/com.google.pixel.vibrator.hal.pk8 Binary files differnew file mode 100644 index 00000000..8a5c5de2 --- /dev/null +++ b/vibrator/cs40l26/apex/com.google.pixel.vibrator.hal.pk8 diff --git a/vibrator/cs40l26/apex/com.google.pixel.vibrator.hal.x509.pem b/vibrator/cs40l26/apex/com.google.pixel.vibrator.hal.x509.pem new file mode 100644 index 00000000..f1c4b481 --- /dev/null +++ b/vibrator/cs40l26/apex/com.google.pixel.vibrator.hal.x509.pem @@ -0,0 +1,34 @@ +-----BEGIN CERTIFICATE----- +MIIF3zCCA8cCFG61gvRZ1Gc1PG7iECvnY7zKSCaEMA0GCSqGSIb3DQEBCwUAMIGq +MQswCQYDVQQGEwJVUzETMBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNTW91 +bnRhaW4gVmlldzEQMA4GA1UECgwHQW5kcm9pZDEQMA4GA1UECwwHQW5kcm9pZDEi +MCAGCSqGSIb3DQEJARYTYW5kcm9pZEBhbmRyb2lkLmNvbTEmMCQGA1UEAwwdY29t +Lmdvb2dsZS5waXhlbC52aWJyYXRvci5oYWwwIBcNMjIwODA1MTc1NTU4WhgPNDc2 +MDA3MDExNzU1NThaMIGqMQswCQYDVQQGEwJVUzETMBEGA1UECAwKQ2FsaWZvcm5p +YTEWMBQGA1UEBwwNTW91bnRhaW4gVmlldzEQMA4GA1UECgwHQW5kcm9pZDEQMA4G +A1UECwwHQW5kcm9pZDEiMCAGCSqGSIb3DQEJARYTYW5kcm9pZEBhbmRyb2lkLmNv +bTEmMCQGA1UEAwwdY29tLmdvb2dsZS5waXhlbC52aWJyYXRvci5oYWwwggIiMA0G +CSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCVoc9F0h6gf3M/Sm5K9rt8W1ZmB/Lu +fMlkMAZXqMWRbCYVPDg0hQkICLNEOEM76oFvMBCSS2HsZwdXgAguwy3IBhpuMC+t +mNkA9+6gAXXE3nBwQ/PjphS9vPPIQ+cvbEBiwaAFpAWCx9nb5VLBrkNBIFDuzE+t +He6sj8kD8vVWKqSEwHHwFdzvXLkSQvYKhrWFltcuUmkpxnHtfVJAH/iO7Vb/jR+s +H1YVqJcS35OjnjYzjDfQTr7aqV09K/3X9Srai5o0BiWRpcpytmK5MEIqEPJvewRz +e76Uw7kMO68f5OS6NV1iXqCI4l/k5v+Q0jlxecqJdWANWSegR5cli3eUS/zEDmZb +2OlrNACsr4hpGu5M2EuVwxg89SbKlUU2ughE6+c/56c45WRalyailaWltN5SF9zK +RaW1iGS3GDBXeVFqavydJLs9NDdEd0x9wAEdvN8rhrChkhjq18L9ls4d6JIC629V +n/GT63AHfulpklt5ueGOT1vQZdg6Z8LipcwAzIpTUZJEyVGbGp/o3jf80yYdfftU +AT51+i89xiJwKDBnCS0FDT54NFpp9yCKTZtLIGa+GweW4kVya2AG6iFdf0/GXPGz +khOPxhIyC8IfvK+Ozryn2X1ied44gHy6dKA8QXa5nRRxVPnOjJTzQp+vRty+dvzz +imdJENRezYdKXQIDAQABMA0GCSqGSIb3DQEBCwUAA4ICAQA/0IUBeq+xyG7Q8Alb +4x6cNgLhyxqyn1JQ856YsrGZrdRXLz3pVv21hKOW5g4ol7kXMnGcpnympgk8bgux +4YFUNxGtM+2SR2ev3bmh+I0UTEom85k6FIYI22cje7cPJUq2E1V/IUWOSPGZ5A8O +HaW0CKOO9aspyYFXZyWqf9pdzygaqSB1BH2yxr8Hqwdhi7YDRE81RYZHC7KMsq7E +f2KkI/Lw+Q4vKGCcXNXiJrkUNkRWiuS8mbUtrNf4ub2i07zkB+pJ6Z5NhqnPV8v8 +nNVqdPmRnDcW1eRedV2Zx8/kUF8xqDjAYAv6i+D4Qmz2wjh63/EkUXqoyn/yrDBL +DGzQWfZvLsXKYPFcEIvGTIkZnKSaLbI5ReO+hZ4i4BgCs/dYvVX27mfTGkwsj11j +w4SmQuMxqMA26HQDhL7TPkBmfzvD53YC57wbioLhAUgQM5pwi3utx8oj+zcoqNxl +x6PiaWCWR0pVjGyI4UTMn2wyf8NlqEa7fJI74S035ZK6eqfP2wfZlzV5zpIOnmR1 +GK7oIjbG2NNVINiOSEhPD9CMYxX6UXh+C3vD37QMdRbcLahvjlFVkPCVi1lPf/Js +Rjj9ZCh2BT/ks2KMIHzR7oFQZzMOiz8MP9HrsS1QLyKMxco2jyI2jL8y/j3VOsZz +3ZkM2dl0vADvHBwHZH3/v/InMA== +-----END CERTIFICATE----- diff --git a/vibrator/cs40l26/apex/file_contexts b/vibrator/cs40l26/apex/file_contexts new file mode 100644 index 00000000..5795d2b5 --- /dev/null +++ b/vibrator/cs40l26/apex/file_contexts @@ -0,0 +1,3 @@ +(/.*)? u:object_r:vendor_file:s0 +/bin/hw/android\.hardware\.vibrator-service\.cs40l26 u:object_r:hal_vibrator_default_exec:s0 + diff --git a/vibrator/cs40l26/device-stereo.mk b/vibrator/cs40l26/device-stereo.mk index 44d2b92c..c9212882 100644 --- a/vibrator/cs40l26/device-stereo.mk +++ b/vibrator/cs40l26/device-stereo.mk @@ -1,6 +1,7 @@ PRODUCT_PACKAGES += \ android.hardware.vibrator-service.cs40l26 \ - android.hardware.vibrator-service.cs40l26-dual \ + android.hardware.vibrator-service.cs40l26-dual BOARD_SEPOLICY_DIRS += \ - hardware/google/pixel-sepolicy/vibrator/cs40l26 \ + hardware/google/pixel-sepolicy/vibrator/common \ + hardware/google/pixel-sepolicy/vibrator/cs40l26 diff --git a/vibrator/cs40l26/device.mk b/vibrator/cs40l26/device.mk index 5a3dd4f8..24d68d2c 100644 --- a/vibrator/cs40l26/device.mk +++ b/vibrator/cs40l26/device.mk @@ -1,5 +1,8 @@ -PRODUCT_PACKAGES += \ - android.hardware.vibrator-service.cs40l26 +ifeq ($(LOCAL_PREFER_VENDOR_APEX),true) +PRODUCT_PACKAGES += com.google.pixel.vibrator.hal +else +PRODUCT_PACKAGES += android.hardware.vibrator-service.cs40l26 +endif BOARD_SEPOLICY_DIRS += \ hardware/google/pixel-sepolicy/vibrator/common \ diff --git a/vibrator/cs40l26/service.cpp b/vibrator/cs40l26/service.cpp index 27173d9f..2068b6da 100644 --- a/vibrator/cs40l26/service.cpp +++ b/vibrator/cs40l26/service.cpp @@ -15,39 +15,30 @@ */ #include <android/binder_manager.h> #include <android/binder_process.h> -#include <binder/IServiceManager.h> -#include <binder/ProcessState.h> #include <log/log.h> #include "Hardware.h" +#include "Stats.h" #include "Vibrator.h" using ::aidl::android::hardware::vibrator::HwApi; using ::aidl::android::hardware::vibrator::HwCal; +using ::aidl::android::hardware::vibrator::StatsApi; using ::aidl::android::hardware::vibrator::Vibrator; -using ::android::defaultServiceManager; -using ::android::ProcessState; -using ::android::sp; -using ::android::String16; #if !defined(VIBRATOR_NAME) #define VIBRATOR_NAME "default" #endif int main() { - auto svc = ndk::SharedRefBase::make<Vibrator>(std::make_unique<HwApi>(), - std::make_unique<HwCal>()); + auto svc = ndk::SharedRefBase::make<Vibrator>( + std::make_unique<HwApi>(), std::make_unique<HwCal>(), std::make_unique<StatsApi>()); const auto svcName = std::string() + svc->descriptor + "/" + VIBRATOR_NAME; - ProcessState::initWithDriver("/dev/vndbinder"); - auto svcBinder = svc->asBinder(); binder_status_t status = AServiceManager_addService(svcBinder.get(), svcName.c_str()); LOG_ALWAYS_FATAL_IF(status != STATUS_OK); - ProcessState::self()->setThreadPoolMaxThreadCount(1); - ProcessState::self()->startThreadPool(); - ABinderProcess_setThreadPoolMaxThreadCount(0); ABinderProcess_joinThreadPool(); diff --git a/vibrator/cs40l26/tests/Android.bp b/vibrator/cs40l26/tests/Android.bp new file mode 100644 index 00000000..79821d2d --- /dev/null +++ b/vibrator/cs40l26/tests/Android.bp @@ -0,0 +1,35 @@ +// +// Copyright (C) 2022 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. + +package { + default_applicable_licenses: ["Android-Apache-2.0"], +} + +cc_test { + name: "VibratorHalCs40l26TestSuite", + defaults: ["VibratorHalCs40l26TestDefaults"], + srcs: [ + "test-hwcal.cpp", + "test-hwapi.cpp", + "test-vibrator.cpp", + ], + static_libs: [ + "libc++fs", + "libgmock", + ], + shared_libs: [ + "libbase", + ], +} diff --git a/vibrator/cs40l26/tests/mocks.h b/vibrator/cs40l26/tests/mocks.h new file mode 100644 index 00000000..dda31f24 --- /dev/null +++ b/vibrator/cs40l26/tests/mocks.h @@ -0,0 +1,101 @@ +/* + * Copyright (C) 2022 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. + */ +#ifndef ANDROID_HARDWARE_VIBRATOR_TEST_MOCKS_H +#define ANDROID_HARDWARE_VIBRATOR_TEST_MOCKS_H + +#include <aidl/android/hardware/vibrator/BnVibratorCallback.h> + +#include "Vibrator.h" + +class MockApi : public ::aidl::android::hardware::vibrator::Vibrator::HwApi { + public: + MOCK_METHOD0(destructor, void()); + MOCK_METHOD1(setF0, bool(std::string value)); + MOCK_METHOD1(setF0Offset, bool(uint32_t value)); + MOCK_METHOD1(setRedc, bool(std::string value)); + MOCK_METHOD1(setQ, bool(std::string value)); + MOCK_METHOD1(getEffectCount, bool(uint32_t *value)); + MOCK_METHOD2(pollVibeState, bool(uint32_t value, int32_t timeoutMs)); + MOCK_METHOD0(hasOwtFreeSpace, bool()); + MOCK_METHOD1(getOwtFreeSpace, bool(uint32_t *value)); + MOCK_METHOD1(setF0CompEnable, bool(bool value)); + MOCK_METHOD1(setRedcCompEnable, bool(bool value)); + MOCK_METHOD1(setMinOnOffInterval, bool(uint32_t value)); + MOCK_METHOD0(initFF, bool()); + MOCK_METHOD0(getContextScale, uint32_t()); + MOCK_METHOD0(getContextEnable, bool()); + MOCK_METHOD0(getContextSettlingTime, uint32_t()); + MOCK_METHOD0(getContextCooldownTime, uint32_t()); + MOCK_METHOD0(getContextFadeEnable, bool()); + MOCK_METHOD1(setFFGain, bool(uint16_t value)); + MOCK_METHOD2(setFFEffect, bool(struct ff_effect *effect, uint16_t timeoutMs)); + MOCK_METHOD2(setFFPlay, bool(int8_t index, bool value)); + MOCK_METHOD2(getHapticAlsaDevice, bool(int *card, int *device)); + MOCK_METHOD4(setHapticPcmAmp, bool(struct pcm **haptic_pcm, bool enable, int card, int device)); + MOCK_METHOD5(uploadOwtEffect, + bool(const uint8_t *owtData, const uint32_t numBytes, struct ff_effect *effect, + uint32_t *outEffectIndex, int *status)); + MOCK_METHOD2(eraseOwtEffect, bool(int8_t effectIndex, std::vector<ff_effect> *effect)); + MOCK_METHOD1(debug, void(int fd)); + + ~MockApi() override { destructor(); }; +}; + +class MockCal : public ::aidl::android::hardware::vibrator::Vibrator::HwCal { + public: + MOCK_METHOD0(destructor, void()); + MOCK_METHOD1(getVersion, bool(uint32_t *value)); + MOCK_METHOD1(getF0, bool(std::string &value)); + MOCK_METHOD1(getRedc, bool(std::string &value)); + MOCK_METHOD1(getQ, bool(std::string &value)); + MOCK_METHOD1(getLongFrequencyShift, bool(int32_t *value)); + MOCK_METHOD1(getTickVolLevels, bool(std::array<uint32_t, 2> *value)); + MOCK_METHOD1(getClickVolLevels, bool(std::array<uint32_t, 2> *value)); + MOCK_METHOD1(getLongVolLevels, bool(std::array<uint32_t, 2> *value)); + MOCK_METHOD0(isChirpEnabled, bool()); + MOCK_METHOD1(getSupportedPrimitives, bool(uint32_t *value)); + MOCK_METHOD1(getDeviceMass, bool(float *value)); + MOCK_METHOD1(getLocCoeff, bool(float *value)); + MOCK_METHOD0(isF0CompEnabled, bool()); + MOCK_METHOD0(isRedcCompEnabled, bool()); + MOCK_METHOD1(debug, void(int fd)); + + ~MockCal() override { destructor(); }; + // b/132668253: Workaround gMock Compilation Issue + bool getF0(std::string *value) { return getF0(*value); } + bool getRedc(std::string *value) { return getRedc(*value); } + bool getQ(std::string *value) { return getQ(*value); } +}; + +class MockStats : public ::aidl::android::hardware::vibrator::Vibrator::StatsApi { + public: + MOCK_METHOD0(destructor, void()); + MOCK_METHOD1(logPrimitive, bool(uint16_t effectIndex)); + MOCK_METHOD2(logWaveform, bool(uint16_t effectIndex, int32_t duration)); + MOCK_METHOD1(logError, bool(uint16_t errorIndex)); + MOCK_METHOD1(logLatencyStart, bool(uint16_t latencyIndex)); + MOCK_METHOD0(logLatencyEnd, bool()); + MOCK_METHOD1(debug, void(int fd)); + + ~MockStats() override { destructor(); }; +}; + +class MockVibratorCallback : public aidl::android::hardware::vibrator::BnVibratorCallback { + public: + MOCK_METHOD(ndk::ScopedAStatus, onComplete, ()); +}; + +#endif // ANDROID_HARDWARE_VIBRATOR_TEST_MOCKS_H diff --git a/vibrator/cs40l26/tests/test-hwapi.cpp b/vibrator/cs40l26/tests/test-hwapi.cpp new file mode 100644 index 00000000..cc4d4652 --- /dev/null +++ b/vibrator/cs40l26/tests/test-hwapi.cpp @@ -0,0 +1,288 @@ +/* + * Copyright (C) 2022 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. + */ + +#include <android-base/file.h> +#include <cutils/fs.h> +#include <gtest/gtest.h> + +#include <cstdlib> +#include <fstream> + +#include "Hardware.h" + +namespace aidl { +namespace android { +namespace hardware { +namespace vibrator { + +using ::testing::Test; +using ::testing::TestParamInfo; +using ::testing::ValuesIn; +using ::testing::WithParamInterface; + +class HwApiTest : public Test { + private: + static constexpr const char *FILE_NAMES[]{ + "calibration/f0_stored", + "default/f0_offset", + "calibration/redc_stored", + "calibration/q_stored", + "default/f0_comp_enable", + "default/redc_comp_enable", + "default/owt_free_space", + "default/num_waves", + "default/delay_before_stop_playback_us", + }; + + public: + void SetUp() override { + std::string prefix; + for (auto n : FILE_NAMES) { + auto name = std::filesystem::path(n); + auto path = std::filesystem::path(mFilesDir.path) / name; + fs_mkdirs(path.c_str(), S_IRWXU); + std::ofstream touch{path}; + mFileMap[name] = path; + } + prefix = std::filesystem::path(mFilesDir.path) / ""; + setenv("HWAPI_PATH_PREFIX", prefix.c_str(), true); + mHwApi = std::make_unique<HwApi>(); + + for (auto n : FILE_NAMES) { + auto name = std::filesystem::path(n); + auto path = std::filesystem::path(mEmptyDir.path) / name; + } + prefix = std::filesystem::path(mEmptyDir.path) / ""; + setenv("HWAPI_PATH_PREFIX", prefix.c_str(), true); + mNoApi = std::make_unique<HwApi>(); + } + + void TearDown() override { verifyContents(); } + + static auto ParamNameFixup(std::string str) { + std::replace(str.begin(), str.end(), '/', '_'); + return str; + } + + protected: + // Set expected file content for a test. + template <typename T> + void expectContent(const std::string &name, const T &value) { + mExpectedContent[name] << value << std::endl; + } + + // Set actual file content for an input test. + template <typename T> + void updateContent(const std::string &name, const T &value) { + std::ofstream(mFileMap[name]) << value << std::endl; + } + + template <typename T> + void expectAndUpdateContent(const std::string &name, const T &value) { + expectContent(name, value); + updateContent(name, value); + } + + // Compare all file contents against expected contents. + void verifyContents() { + for (auto &a : mFileMap) { + std::ifstream file{a.second}; + std::string expect = mExpectedContent[a.first].str(); + std::string actual = std::string(std::istreambuf_iterator<char>(file), + std::istreambuf_iterator<char>()); + EXPECT_EQ(expect, actual) << a.first; + } + } + + protected: + std::unique_ptr<Vibrator::HwApi> mHwApi; + std::unique_ptr<Vibrator::HwApi> mNoApi; + std::map<std::string, std::string> mFileMap; + TemporaryDir mFilesDir; + TemporaryDir mEmptyDir; + std::map<std::string, std::stringstream> mExpectedContent; +}; + +template <typename T> +class HwApiTypedTest : public HwApiTest, + public WithParamInterface<std::tuple<std::string, std::function<T>>> { + public: + static auto PrintParam(const TestParamInfo<typename HwApiTypedTest::ParamType> &info) { + return ParamNameFixup(std::get<0>(info.param)); + } + static auto MakeParam(std::string name, std::function<T> func) { + return std::make_tuple(name, func); + } +}; + +using HasTest = HwApiTypedTest<bool(Vibrator::HwApi &)>; + +TEST_P(HasTest, success_returnsTrue) { + auto param = GetParam(); + auto func = std::get<1>(param); + + EXPECT_TRUE(func(*mHwApi)); +} + +TEST_P(HasTest, success_returnsFalse) { + auto param = GetParam(); + auto func = std::get<1>(param); + + EXPECT_FALSE(func(*mNoApi)); +} + +INSTANTIATE_TEST_CASE_P(HwApiTests, HasTest, + ValuesIn({ + HasTest::MakeParam("default/owt_free_space", + &Vibrator::HwApi::hasOwtFreeSpace), + }), + HasTest::PrintParam); + +using GetUint32Test = HwApiTypedTest<bool(Vibrator::HwApi &, uint32_t *)>; + +TEST_P(GetUint32Test, success) { + auto param = GetParam(); + auto name = std::get<0>(param); + auto func = std::get<1>(param); + uint32_t expect = std::rand(); + uint32_t actual = ~expect; + + expectAndUpdateContent(name, expect); + + EXPECT_TRUE(func(*mHwApi, &actual)); + EXPECT_EQ(expect, actual); +} + +TEST_P(GetUint32Test, failure) { + auto param = GetParam(); + auto func = std::get<1>(param); + uint32_t value; + + EXPECT_FALSE(func(*mNoApi, &value)); +} + +INSTANTIATE_TEST_CASE_P(HwApiTests, GetUint32Test, + ValuesIn({ + GetUint32Test::MakeParam("default/num_waves", + &Vibrator::HwApi::getEffectCount), + GetUint32Test::MakeParam("default/owt_free_space", + &Vibrator::HwApi::getOwtFreeSpace), + }), + GetUint32Test::PrintParam); + +using SetBoolTest = HwApiTypedTest<bool(Vibrator::HwApi &, bool)>; + +TEST_P(SetBoolTest, success_returnsTrue) { + auto param = GetParam(); + auto name = std::get<0>(param); + auto func = std::get<1>(param); + + expectContent(name, "1"); + + EXPECT_TRUE(func(*mHwApi, true)); +} + +TEST_P(SetBoolTest, success_returnsFalse) { + auto param = GetParam(); + auto name = std::get<0>(param); + auto func = std::get<1>(param); + + expectContent(name, "0"); + + EXPECT_TRUE(func(*mHwApi, false)); +} + +TEST_P(SetBoolTest, failure) { + auto param = GetParam(); + auto func = std::get<1>(param); + + EXPECT_FALSE(func(*mNoApi, true)); + EXPECT_FALSE(func(*mNoApi, false)); +} + +INSTANTIATE_TEST_CASE_P(HwApiTests, SetBoolTest, + ValuesIn({ + SetBoolTest::MakeParam("default/f0_comp_enable", + &Vibrator::HwApi::setF0CompEnable), + SetBoolTest::MakeParam("default/redc_comp_enable", + &Vibrator::HwApi::setRedcCompEnable), + }), + SetBoolTest::PrintParam); + +using SetUint32Test = HwApiTypedTest<bool(Vibrator::HwApi &, uint32_t)>; + +TEST_P(SetUint32Test, success) { + auto param = GetParam(); + auto name = std::get<0>(param); + auto func = std::get<1>(param); + uint32_t value = std::rand(); + + expectContent(name, value); + + EXPECT_TRUE(func(*mHwApi, value)); +} + +TEST_P(SetUint32Test, failure) { + auto param = GetParam(); + auto func = std::get<1>(param); + uint32_t value = std::rand(); + + EXPECT_FALSE(func(*mNoApi, value)); +} + +INSTANTIATE_TEST_CASE_P(HwApiTests, SetUint32Test, + ValuesIn({ + SetUint32Test::MakeParam("default/f0_offset", + &Vibrator::HwApi::setF0Offset), + SetUint32Test::MakeParam("default/delay_before_stop_playback_us", + &Vibrator::HwApi::setMinOnOffInterval), + }), + SetUint32Test::PrintParam); + +using SetStringTest = HwApiTypedTest<bool(Vibrator::HwApi &, std::string)>; + +TEST_P(SetStringTest, success) { + auto param = GetParam(); + auto name = std::get<0>(param); + auto func = std::get<1>(param); + std::string value = TemporaryFile().path; + + expectContent(name, value); + + EXPECT_TRUE(func(*mHwApi, value)); +} + +TEST_P(SetStringTest, failure) { + auto param = GetParam(); + auto func = std::get<1>(param); + std::string value = TemporaryFile().path; + + EXPECT_FALSE(func(*mNoApi, value)); +} + +INSTANTIATE_TEST_CASE_P( + HwApiTests, SetStringTest, + ValuesIn({ + SetStringTest::MakeParam("calibration/f0_stored", &Vibrator::HwApi::setF0), + SetStringTest::MakeParam("calibration/redc_stored", &Vibrator::HwApi::setRedc), + SetStringTest::MakeParam("calibration/q_stored", &Vibrator::HwApi::setQ), + }), + SetStringTest::PrintParam); + +} // namespace vibrator +} // namespace hardware +} // namespace android +} // namespace aidl diff --git a/vibrator/cs40l26/tests/test-hwcal.cpp b/vibrator/cs40l26/tests/test-hwcal.cpp new file mode 100644 index 00000000..e482b6c6 --- /dev/null +++ b/vibrator/cs40l26/tests/test-hwcal.cpp @@ -0,0 +1,386 @@ +/* + * Copyright (C) 2022 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. + */ + +#include <android-base/file.h> +#include <gtest/gtest.h> + +#include <fstream> + +#include "Hardware.h" + +namespace aidl { +namespace android { +namespace hardware { +namespace vibrator { + +using ::testing::Test; + +class HwCalTest : public Test { + protected: + static constexpr std::array<uint32_t, 2> V_TICK_DEFAULT = {1, 100}; + static constexpr std::array<uint32_t, 2> V_CLICK_DEFAULT = {1, 100}; + static constexpr std::array<uint32_t, 2> V_LONG_DEFAULT = {1, 100}; + + public: + void SetUp() override { setenv("CALIBRATION_FILEPATH", mCalFile.path, true); } + + private: + template <typename T> + static void pack(std::ostream &stream, const T &value, std::string lpad, std::string rpad) { + stream << lpad << value << rpad; + } + + template <typename T, typename std::array<T, 0>::size_type N> + static void pack(std::ostream &stream, const std::array<T, N> &value, std::string lpad, + std::string rpad) { + for (auto &entry : value) { + pack(stream, entry, lpad, rpad); + } + } + + protected: + void createHwCal() { mHwCal = std::make_unique<HwCal>(); } + + template <typename T> + void write(const std::string key, const T &value, std::string lpad = " ", + std::string rpad = "") { + std::ofstream calfile{mCalFile.path, std::ios_base::app}; + calfile << key << ":"; + pack(calfile, value, lpad, rpad); + calfile << std::endl; + } + + void unlink() { ::unlink(mCalFile.path); } + + protected: + std::unique_ptr<Vibrator::HwCal> mHwCal; + TemporaryFile mCalFile; +}; + +TEST_F(HwCalTest, f0_measured) { + uint32_t randInput = std::rand(); + std::string expect = std::to_string(randInput); + std::string actual = std::to_string(~randInput); + + write("f0_measured", expect); + + createHwCal(); + + EXPECT_TRUE(mHwCal->getF0(&actual)); + EXPECT_EQ(expect, actual); +} + +TEST_F(HwCalTest, f0_missing) { + std::string actual; + + createHwCal(); + + EXPECT_FALSE(mHwCal->getF0(&actual)); +} + +TEST_F(HwCalTest, redc_measured) { + uint32_t randInput = std::rand(); + std::string expect = std::to_string(randInput); + std::string actual = std::to_string(~randInput); + + write("redc_measured", expect); + + createHwCal(); + + EXPECT_TRUE(mHwCal->getRedc(&actual)); + EXPECT_EQ(expect, actual); +} + +TEST_F(HwCalTest, redc_missing) { + std::string actual; + + createHwCal(); + + EXPECT_FALSE(mHwCal->getRedc(&actual)); +} + +TEST_F(HwCalTest, q_measured) { + uint32_t randInput = std::rand(); + std::string expect = std::to_string(randInput); + std::string actual = std::to_string(~randInput); + + write("q_measured", expect); + + createHwCal(); + + EXPECT_TRUE(mHwCal->getQ(&actual)); + EXPECT_EQ(expect, actual); +} + +TEST_F(HwCalTest, q_missing) { + std::string actual; + + createHwCal(); + + EXPECT_FALSE(mHwCal->getQ(&actual)); +} + +TEST_F(HwCalTest, v_levels) { + std::array<uint32_t, 2> expect; + std::array<uint32_t, 2> actual; + + // voltage for tick effects + std::transform(expect.begin(), expect.end(), actual.begin(), [](uint32_t &e) { + e = std::rand(); + return ~e; + }); + + write("v_tick", expect); + + createHwCal(); + + EXPECT_TRUE(mHwCal->getTickVolLevels(&actual)); + EXPECT_EQ(expect, actual); + + // voltage for click effects + std::transform(expect.begin(), expect.end(), actual.begin(), [](uint32_t &e) { + e = std::rand(); + return ~e; + }); + + write("v_click", expect); + + createHwCal(); + + EXPECT_TRUE(mHwCal->getClickVolLevels(&actual)); + EXPECT_EQ(expect, actual); + + // voltage for long effects + std::transform(expect.begin(), expect.end(), actual.begin(), [](uint32_t &e) { + e = std::rand(); + return ~e; + }); + + write("v_long", expect); + + createHwCal(); + + EXPECT_TRUE(mHwCal->getLongVolLevels(&actual)); + EXPECT_EQ(expect, actual); +} + +TEST_F(HwCalTest, v_missing) { + std::array<uint32_t, 2> expect = V_TICK_DEFAULT; + std::array<uint32_t, 2> actual; + + std::transform(expect.begin(), expect.end(), actual.begin(), [](uint32_t &e) { return ~e; }); + + createHwCal(); + + EXPECT_TRUE(mHwCal->getTickVolLevels(&actual)); + EXPECT_EQ(expect, actual); + + expect = V_CLICK_DEFAULT; + + std::transform(expect.begin(), expect.end(), actual.begin(), [](uint32_t &e) { return ~e; }); + + createHwCal(); + + EXPECT_TRUE(mHwCal->getClickVolLevels(&actual)); + EXPECT_EQ(expect, actual); + + expect = V_LONG_DEFAULT; + + std::transform(expect.begin(), expect.end(), actual.begin(), [](uint32_t &e) { return ~e; }); + + createHwCal(); + + EXPECT_TRUE(mHwCal->getLongVolLevels(&actual)); + EXPECT_EQ(expect, actual); +} + +TEST_F(HwCalTest, v_short) { + std::array<uint32_t, 2> expect = V_TICK_DEFAULT; + std::array<uint32_t, 2> actual; + + std::transform(expect.begin(), expect.end(), actual.begin(), [](uint32_t &e) { return ~e; }); + + write("v_tick", std::array<uint32_t, expect.size() - 1>()); + write("v_click", std::array<uint32_t, expect.size() - 1>()); + write("v_long", std::array<uint32_t, expect.size() - 1>()); + + createHwCal(); + + EXPECT_TRUE(mHwCal->getTickVolLevels(&actual)); + EXPECT_EQ(expect, actual); + + expect = V_CLICK_DEFAULT; + EXPECT_TRUE(mHwCal->getClickVolLevels(&actual)); + EXPECT_EQ(expect, actual); + + expect = V_LONG_DEFAULT; + EXPECT_TRUE(mHwCal->getLongVolLevels(&actual)); + EXPECT_EQ(expect, actual); +} + +TEST_F(HwCalTest, v_long) { + std::array<uint32_t, 2> expect = V_TICK_DEFAULT; + std::array<uint32_t, 2> actual; + + std::transform(expect.begin(), expect.end(), actual.begin(), [](uint32_t &e) { return ~e; }); + + write("v_tick", std::array<uint32_t, expect.size() + 1>()); + write("v_click", std::array<uint32_t, expect.size() + 1>()); + write("v_long", std::array<uint32_t, expect.size() + 1>()); + + createHwCal(); + + EXPECT_TRUE(mHwCal->getTickVolLevels(&actual)); + EXPECT_EQ(expect, actual); + + expect = V_CLICK_DEFAULT; + EXPECT_TRUE(mHwCal->getClickVolLevels(&actual)); + EXPECT_EQ(expect, actual); + + expect = V_LONG_DEFAULT; + EXPECT_TRUE(mHwCal->getLongVolLevels(&actual)); + EXPECT_EQ(expect, actual); +} + +TEST_F(HwCalTest, v_nofile) { + std::array<uint32_t, 2> expect = V_TICK_DEFAULT; + std::array<uint32_t, 2> actual; + + std::transform(expect.begin(), expect.end(), actual.begin(), [](uint32_t &e) { return ~e; }); + + write("v_tick", actual); + write("v_click", actual); + write("v_long", actual); + unlink(); + + createHwCal(); + + EXPECT_TRUE(mHwCal->getTickVolLevels(&actual)); + EXPECT_EQ(expect, actual); + + expect = V_CLICK_DEFAULT; + EXPECT_TRUE(mHwCal->getClickVolLevels(&actual)); + EXPECT_EQ(expect, actual); + + expect = V_LONG_DEFAULT; + EXPECT_TRUE(mHwCal->getLongVolLevels(&actual)); + EXPECT_EQ(expect, actual); +} + +TEST_F(HwCalTest, multiple) { + uint32_t randInput = std::rand(); + std::string f0Expect = std::to_string(randInput); + std::string f0Actual = std::to_string(~randInput); + randInput = std::rand(); + std::string redcExpect = std::to_string(randInput); + std::string redcActual = std::to_string(~randInput); + randInput = std::rand(); + std::string qExpect = std::to_string(randInput); + std::string qActual = std::to_string(~randInput); + std::array<uint32_t, 2> volTickExpect, volClickExpect, volLongExpect; + std::array<uint32_t, 2> volActual; + + std::transform(volTickExpect.begin(), volTickExpect.end(), volActual.begin(), [](uint32_t &e) { + e = std::rand(); + return ~e; + }); + + write("f0_measured", f0Expect); + write("redc_measured", redcExpect); + write("q_measured", qExpect); + write("v_tick", volTickExpect); + std::transform(volClickExpect.begin(), volClickExpect.end(), volActual.begin(), + [](uint32_t &e) { + e = std::rand(); + return ~e; + }); + write("v_click", volClickExpect); + std::transform(volLongExpect.begin(), volLongExpect.end(), volActual.begin(), [](uint32_t &e) { + e = std::rand(); + return ~e; + }); + write("v_long", volLongExpect); + + createHwCal(); + + EXPECT_TRUE(mHwCal->getF0(&f0Actual)); + EXPECT_EQ(f0Expect, f0Actual); + EXPECT_TRUE(mHwCal->getRedc(&redcActual)); + EXPECT_EQ(redcExpect, redcActual); + EXPECT_TRUE(mHwCal->getQ(&qActual)); + EXPECT_EQ(qExpect, qActual); + EXPECT_TRUE(mHwCal->getTickVolLevels(&volActual)); + EXPECT_EQ(volTickExpect, volActual); + EXPECT_TRUE(mHwCal->getClickVolLevels(&volActual)); + EXPECT_EQ(volClickExpect, volActual); + EXPECT_TRUE(mHwCal->getLongVolLevels(&volActual)); + EXPECT_EQ(volLongExpect, volActual); +} + +TEST_F(HwCalTest, trimming) { + uint32_t randInput = std::rand(); + std::string f0Expect = std::to_string(randInput); + std::string f0Actual = std::to_string(~randInput); + randInput = std::rand(); + std::string redcExpect = std::to_string(randInput); + std::string redcActual = std::to_string(randInput); + randInput = std::rand(); + std::string qExpect = std::to_string(randInput); + std::string qActual = std::to_string(randInput); + std::array<uint32_t, 2> volTickExpect, volClickExpect, volLongExpect; + std::array<uint32_t, 2> volActual; + + std::transform(volTickExpect.begin(), volTickExpect.end(), volActual.begin(), [](uint32_t &e) { + e = std::rand(); + return ~e; + }); + + write("f0_measured", f0Expect, " \t", "\t "); + write("redc_measured", redcExpect, " \t", "\t "); + write("q_measured", qExpect, " \t", "\t "); + write("v_tick", volTickExpect, " \t", "\t "); + std::transform(volClickExpect.begin(), volClickExpect.end(), volActual.begin(), + [](uint32_t &e) { + e = std::rand(); + return ~e; + }); + write("v_click", volClickExpect, " \t", "\t "); + std::transform(volLongExpect.begin(), volLongExpect.end(), volActual.begin(), [](uint32_t &e) { + e = std::rand(); + return ~e; + }); + write("v_long", volLongExpect, " \t", "\t "); + + createHwCal(); + + EXPECT_TRUE(mHwCal->getF0(&f0Actual)); + EXPECT_EQ(f0Expect, f0Actual); + EXPECT_TRUE(mHwCal->getRedc(&redcActual)); + EXPECT_EQ(redcExpect, redcActual); + EXPECT_TRUE(mHwCal->getQ(&qActual)); + EXPECT_EQ(qExpect, qActual); + EXPECT_TRUE(mHwCal->getTickVolLevels(&volActual)); + EXPECT_EQ(volTickExpect, volActual); + EXPECT_TRUE(mHwCal->getClickVolLevels(&volActual)); + EXPECT_EQ(volClickExpect, volActual); + EXPECT_TRUE(mHwCal->getLongVolLevels(&volActual)); + EXPECT_EQ(volLongExpect, volActual); +} + +} // namespace vibrator +} // namespace hardware +} // namespace android +} // namespace aidl diff --git a/vibrator/cs40l26/tests/test-vibrator.cpp b/vibrator/cs40l26/tests/test-vibrator.cpp new file mode 100644 index 00000000..ce9808bd --- /dev/null +++ b/vibrator/cs40l26/tests/test-vibrator.cpp @@ -0,0 +1,729 @@ +/* + * Copyright (C) 2022 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. + */ + +#include <aidl/android/hardware/vibrator/BnVibratorCallback.h> +#include <android-base/logging.h> +#include <gmock/gmock.h> +#include <gtest/gtest.h> +#include <linux/input.h> +#include <linux/uinput.h> + +#include <future> + +#include "Stats.h" +#include "Vibrator.h" +#include "mocks.h" +#include "types.h" +#include "utils.h" + +namespace aidl { +namespace android { +namespace hardware { +namespace vibrator { + +using ::testing::_; +using ::testing::AnyNumber; +using ::testing::Assign; +using ::testing::AtLeast; +using ::testing::AtMost; +using ::testing::Combine; +using ::testing::DoAll; +using ::testing::DoDefault; +using ::testing::Exactly; +using ::testing::Expectation; +using ::testing::ExpectationSet; +using ::testing::Ge; +using ::testing::Mock; +using ::testing::MockFunction; +using ::testing::Range; +using ::testing::Return; +using ::testing::Sequence; +using ::testing::SetArgPointee; +using ::testing::SetArgReferee; +using ::testing::Test; +using ::testing::TestParamInfo; +using ::testing::ValuesIn; +using ::testing::WithParamInterface; + +// Forward Declarations + +static EffectQueue Queue(const QueueEffect &effect); +static EffectQueue Queue(const QueueDelay &delay); +template <typename T, typename U, typename... Args> +static EffectQueue Queue(const T &first, const U &second, Args... rest); + +static EffectLevel Level(float intensity, float levelLow, float levelHigh); +static EffectScale Scale(float intensity, float levelLow, float levelHigh); + +// Constants With Arbitrary Values + +static constexpr uint32_t CAL_VERSION = 2; +static constexpr std::array<EffectLevel, 2> V_TICK_DEFAULT = {1, 100}; +static constexpr std::array<EffectLevel, 2> V_CLICK_DEFAULT{1, 100}; +static constexpr std::array<EffectLevel, 2> V_LONG_DEFAULT{1, 100}; +static constexpr std::array<EffectDuration, 14> EFFECT_DURATIONS{ + 0, 100, 12, 1000, 300, 130, 150, 500, 100, 5, 12, 1000, 1000, 1000}; + +// Constants With Prescribed Values + +static const std::map<Effect, EffectIndex> EFFECT_INDEX{ + {Effect::CLICK, 2}, + {Effect::TICK, 2}, + {Effect::HEAVY_CLICK, 2}, + {Effect::TEXTURE_TICK, 9}, +}; +static constexpr uint32_t MIN_ON_OFF_INTERVAL_US = 8500; +static constexpr uint8_t VOLTAGE_SCALE_MAX = 100; +static constexpr int8_t MAX_COLD_START_LATENCY_MS = 6; // I2C Transaction + DSP Return-From-Standby +static constexpr auto POLLING_TIMEOUT = 20; +enum WaveformIndex : uint16_t { + /* Physical waveform */ + WAVEFORM_LONG_VIBRATION_EFFECT_INDEX = 0, + WAVEFORM_RESERVED_INDEX_1 = 1, + WAVEFORM_CLICK_INDEX = 2, + WAVEFORM_SHORT_VIBRATION_EFFECT_INDEX = 3, + WAVEFORM_THUD_INDEX = 4, + WAVEFORM_SPIN_INDEX = 5, + WAVEFORM_QUICK_RISE_INDEX = 6, + WAVEFORM_SLOW_RISE_INDEX = 7, + WAVEFORM_QUICK_FALL_INDEX = 8, + WAVEFORM_LIGHT_TICK_INDEX = 9, + WAVEFORM_LOW_TICK_INDEX = 10, + WAVEFORM_RESERVED_MFG_1, + WAVEFORM_RESERVED_MFG_2, + WAVEFORM_RESERVED_MFG_3, + WAVEFORM_MAX_PHYSICAL_INDEX, + /* OWT waveform */ + WAVEFORM_COMPOSE = WAVEFORM_MAX_PHYSICAL_INDEX, + WAVEFORM_PWLE, + /* + * Refer to <linux/input.h>, the WAVEFORM_MAX_INDEX must not exceed 96. + * #define FF_GAIN 0x60 // 96 in decimal + * #define FF_MAX_EFFECTS FF_GAIN + */ + WAVEFORM_MAX_INDEX, +}; + +static const EffectScale ON_GLOBAL_SCALE{levelToScale(V_LONG_DEFAULT[1])}; +static const EffectIndex ON_EFFECT_INDEX{0}; + +static const std::map<EffectTuple, EffectScale> EFFECT_SCALE{ + {{Effect::TICK, EffectStrength::LIGHT}, + Scale(0.5f * 0.5f, V_CLICK_DEFAULT[0], V_CLICK_DEFAULT[1])}, + {{Effect::TICK, EffectStrength::MEDIUM}, + Scale(0.5f * 0.7f, V_CLICK_DEFAULT[0], V_CLICK_DEFAULT[1])}, + {{Effect::TICK, EffectStrength::STRONG}, + Scale(0.5f * 1.0f, V_CLICK_DEFAULT[0], V_CLICK_DEFAULT[1])}, + {{Effect::CLICK, EffectStrength::LIGHT}, + Scale(0.7f * 0.5f, V_CLICK_DEFAULT[0], V_CLICK_DEFAULT[1])}, + {{Effect::CLICK, EffectStrength::MEDIUM}, + Scale(0.7f * 0.7f, V_CLICK_DEFAULT[0], V_CLICK_DEFAULT[1])}, + {{Effect::CLICK, EffectStrength::STRONG}, + Scale(0.7f * 1.0f, V_CLICK_DEFAULT[0], V_CLICK_DEFAULT[1])}, + {{Effect::HEAVY_CLICK, EffectStrength::LIGHT}, + Scale(1.0f * 0.5f, V_CLICK_DEFAULT[0], V_CLICK_DEFAULT[1])}, + {{Effect::HEAVY_CLICK, EffectStrength::MEDIUM}, + Scale(1.0f * 0.7f, V_CLICK_DEFAULT[0], V_CLICK_DEFAULT[1])}, + {{Effect::HEAVY_CLICK, EffectStrength::STRONG}, + Scale(1.0f * 1.0f, V_CLICK_DEFAULT[0], V_CLICK_DEFAULT[1])}, + {{Effect::TEXTURE_TICK, EffectStrength::LIGHT}, + Scale(0.5f * 0.5f, V_TICK_DEFAULT[0], V_TICK_DEFAULT[1])}, + {{Effect::TEXTURE_TICK, EffectStrength::MEDIUM}, + Scale(0.5f * 0.7f, V_TICK_DEFAULT[0], V_TICK_DEFAULT[1])}, + {{Effect::TEXTURE_TICK, EffectStrength::STRONG}, + Scale(0.5f * 1.0f, V_TICK_DEFAULT[0], V_TICK_DEFAULT[1])}, +}; + +static const std::map<EffectTuple, EffectQueue> EFFECT_QUEUE{ + {{Effect::DOUBLE_CLICK, EffectStrength::LIGHT}, + Queue(QueueEffect{EFFECT_INDEX.at(Effect::CLICK), + Level(0.7f * 0.5f, V_CLICK_DEFAULT[0], V_CLICK_DEFAULT[1])}, + 100, + QueueEffect{EFFECT_INDEX.at(Effect::CLICK), + Level(1.0f * 0.5f, V_CLICK_DEFAULT[0], V_CLICK_DEFAULT[1])})}, + {{Effect::DOUBLE_CLICK, EffectStrength::MEDIUM}, + Queue(QueueEffect{EFFECT_INDEX.at(Effect::CLICK), + Level(0.7f * 0.7f, V_CLICK_DEFAULT[0], V_CLICK_DEFAULT[1])}, + 100, + QueueEffect{EFFECT_INDEX.at(Effect::CLICK), + Level(1.0f * 0.7f, V_CLICK_DEFAULT[0], V_CLICK_DEFAULT[1])})}, + {{Effect::DOUBLE_CLICK, EffectStrength::STRONG}, + Queue(QueueEffect{EFFECT_INDEX.at(Effect::CLICK), + Level(0.7f * 1.0f, V_CLICK_DEFAULT[0], V_CLICK_DEFAULT[1])}, + 100, + QueueEffect{EFFECT_INDEX.at(Effect::CLICK), + Level(1.0f * 1.0f, V_CLICK_DEFAULT[0], V_CLICK_DEFAULT[1])})}, +}; + +EffectQueue Queue(const QueueEffect &effect) { + auto index = std::get<0>(effect); + auto level = std::get<1>(effect); + auto string = std::to_string(index) + "." + std::to_string(level); + auto duration = EFFECT_DURATIONS[index]; + return {string, duration}; +} + +EffectQueue Queue(const QueueDelay &delay) { + auto string = std::to_string(delay); + return {string, delay}; +} + +template <typename T, typename U, typename... Args> +EffectQueue Queue(const T &first, const U &second, Args... rest) { + auto head = Queue(first); + auto tail = Queue(second, rest...); + auto string = std::get<0>(head) + "," + std::get<0>(tail); + auto duration = std::get<1>(head) + std::get<1>(tail); + return {string, duration}; +} + +static EffectLevel Level(float intensity, float levelLow, float levelHigh) { + return std::lround(intensity * (levelHigh - levelLow)) + levelLow; +} + +static EffectScale Scale(float intensity, float levelLow, float levelHigh) { + return levelToScale(Level(intensity, levelLow, levelHigh)); +} + +class VibratorTest : public Test { + public: + void SetUp() override { + setenv("INPUT_EVENT_NAME", "CS40L26TestSuite", true); + std::unique_ptr<MockApi> mockapi; + std::unique_ptr<MockCal> mockcal; + std::unique_ptr<MockStats> mockstats; + + createMock(&mockapi, &mockcal, &mockstats); + createVibrator(std::move(mockapi), std::move(mockcal), std::move(mockstats)); + } + + void TearDown() override { deleteVibrator(); } + + protected: + void createMock(std::unique_ptr<MockApi> *mockapi, std::unique_ptr<MockCal> *mockcal, + std::unique_ptr<MockStats> *mockstats) { + *mockapi = std::make_unique<MockApi>(); + *mockcal = std::make_unique<MockCal>(); + *mockstats = std::make_unique<MockStats>(); + + mMockApi = mockapi->get(); + mMockCal = mockcal->get(); + mMockStats = mockstats->get(); + + ON_CALL(*mMockApi, destructor()).WillByDefault(Assign(&mMockApi, nullptr)); + + ON_CALL(*mMockApi, initFF()).WillByDefault(Return(false)); + ON_CALL(*mMockApi, setFFGain(_)).WillByDefault(Return(true)); + ON_CALL(*mMockApi, setFFEffect(_, _)).WillByDefault(Return(true)); + ON_CALL(*mMockApi, setFFPlay(_, _)).WillByDefault(Return(true)); + ON_CALL(*mMockApi, pollVibeState(_, _)).WillByDefault(Return(true)); + ON_CALL(*mMockApi, uploadOwtEffect(_, _, _, _, _)).WillByDefault(Return(true)); + ON_CALL(*mMockApi, eraseOwtEffect(_, _)).WillByDefault(Return(true)); + + ON_CALL(*mMockApi, getOwtFreeSpace(_)) + .WillByDefault(DoAll(SetArgPointee<0>(11504), Return(true))); + + ON_CALL(*mMockCal, destructor()).WillByDefault(Assign(&mMockCal, nullptr)); + + ON_CALL(*mMockCal, getVersion(_)) + .WillByDefault(DoAll(SetArgPointee<0>(CAL_VERSION), Return(true))); + + ON_CALL(*mMockCal, getTickVolLevels(_)) + .WillByDefault(DoAll(SetArgPointee<0>(V_TICK_DEFAULT), Return(true))); + ON_CALL(*mMockCal, getClickVolLevels(_)) + .WillByDefault(DoAll(SetArgPointee<0>(V_CLICK_DEFAULT), Return(true))); + ON_CALL(*mMockCal, getLongVolLevels(_)) + .WillByDefault(DoAll(SetArgPointee<0>(V_LONG_DEFAULT), Return(true))); + + ON_CALL(*mMockStats, destructor()).WillByDefault(Assign(&mMockStats, nullptr)); + ON_CALL(*mMockStats, logPrimitive(_)).WillByDefault(Return(true)); + ON_CALL(*mMockStats, logWaveform(_, _)).WillByDefault(Return(true)); + ON_CALL(*mMockStats, logLatencyStart(_)).WillByDefault(Return(true)); + ON_CALL(*mMockStats, logLatencyEnd()).WillByDefault(Return(true)); + + relaxMock(false); + } + + void createVibrator(std::unique_ptr<MockApi> mockapi, std::unique_ptr<MockCal> mockcal, + std::unique_ptr<MockStats> mockstats, bool relaxed = true) { + if (relaxed) { + relaxMock(true); + } + mVibrator = ndk::SharedRefBase::make<Vibrator>(std::move(mockapi), std::move(mockcal), + std::move(mockstats)); + if (relaxed) { + relaxMock(false); + } + } + + void deleteVibrator(bool relaxed = true) { + if (relaxed) { + relaxMock(true); + } + mVibrator.reset(); + } + + private: + void relaxMock(bool relax) { + auto times = relax ? AnyNumber() : Exactly(0); + + Mock::VerifyAndClearExpectations(mMockApi); + Mock::VerifyAndClearExpectations(mMockCal); + Mock::VerifyAndClearExpectations(mMockStats); + + EXPECT_CALL(*mMockApi, destructor()).Times(times); + EXPECT_CALL(*mMockApi, setF0(_)).Times(times); + EXPECT_CALL(*mMockApi, setF0Offset(_)).Times(times); + EXPECT_CALL(*mMockApi, setRedc(_)).Times(times); + EXPECT_CALL(*mMockApi, setQ(_)).Times(times); + EXPECT_CALL(*mMockApi, hasOwtFreeSpace()).Times(times); + EXPECT_CALL(*mMockApi, getOwtFreeSpace(_)).Times(times); + EXPECT_CALL(*mMockApi, setF0CompEnable(_)).Times(times); + EXPECT_CALL(*mMockApi, setRedcCompEnable(_)).Times(times); + EXPECT_CALL(*mMockApi, pollVibeState(_, _)).Times(times); + EXPECT_CALL(*mMockApi, initFF()).Times(times); + EXPECT_CALL(*mMockApi, setFFGain(_)).Times(times); + EXPECT_CALL(*mMockApi, setFFEffect(_, _)).Times(times); + EXPECT_CALL(*mMockApi, setFFPlay(_, _)).Times(times); + EXPECT_CALL(*mMockApi, uploadOwtEffect(_, _, _, _, _)).Times(times); + EXPECT_CALL(*mMockApi, eraseOwtEffect(_, _)).Times(times); + EXPECT_CALL(*mMockApi, setMinOnOffInterval(_)).Times(times); + EXPECT_CALL(*mMockApi, getHapticAlsaDevice(_, _)).Times(times); + EXPECT_CALL(*mMockApi, setHapticPcmAmp(_, _, _, _)).Times(times); + + EXPECT_CALL(*mMockApi, debug(_)).Times(times); + + EXPECT_CALL(*mMockCal, destructor()).Times(times); + EXPECT_CALL(*mMockCal, getF0(_)).Times(times); + EXPECT_CALL(*mMockCal, getRedc(_)).Times(times); + EXPECT_CALL(*mMockCal, getQ(_)).Times(times); + EXPECT_CALL(*mMockCal, getTickVolLevels(_)).Times(times); + EXPECT_CALL(*mMockCal, getClickVolLevels(_)).Times(times); + EXPECT_CALL(*mMockCal, getLongVolLevels(_)).Times(times); + EXPECT_CALL(*mMockCal, isChirpEnabled()).Times(times); + EXPECT_CALL(*mMockCal, getLongFrequencyShift(_)).Times(times); + EXPECT_CALL(*mMockCal, isF0CompEnabled()).Times(times); + EXPECT_CALL(*mMockCal, isRedcCompEnabled()).Times(times); + EXPECT_CALL(*mMockCal, debug(_)).Times(times); + + EXPECT_CALL(*mMockStats, destructor()).Times(times); + EXPECT_CALL(*mMockStats, logPrimitive(_)).Times(times); + EXPECT_CALL(*mMockStats, logWaveform(_, _)).Times(times); + EXPECT_CALL(*mMockStats, logLatencyStart(_)).Times(times); + EXPECT_CALL(*mMockStats, logLatencyEnd()).Times(times); + } + + protected: + MockApi *mMockApi; + MockCal *mMockCal; + MockStats *mMockStats; + std::shared_ptr<IVibrator> mVibrator; + uint32_t mEffectIndex; +}; + +TEST_F(VibratorTest, Constructor) { + std::unique_ptr<MockApi> mockapi; + std::unique_ptr<MockCal> mockcal; + std::unique_ptr<MockStats> mockstats; + std::string f0Val = std::to_string(std::rand()); + std::string redcVal = std::to_string(std::rand()); + std::string qVal = std::to_string(std::rand()); + uint32_t calVer; + uint32_t supportedPrimitivesBits = 0x0; + Expectation volGet; + Sequence f0Seq, redcSeq, qSeq, supportedPrimitivesSeq; + + EXPECT_CALL(*mMockApi, destructor()).WillOnce(DoDefault()); + EXPECT_CALL(*mMockCal, destructor()).WillOnce(DoDefault()); + EXPECT_CALL(*mMockStats, destructor()).WillOnce(DoDefault()); + + deleteVibrator(false); + + createMock(&mockapi, &mockcal, &mockstats); + + EXPECT_CALL(*mMockCal, getF0(_)) + .InSequence(f0Seq) + .WillOnce(DoAll(SetArgReferee<0>(f0Val), Return(true))); + EXPECT_CALL(*mMockApi, setF0(f0Val)).InSequence(f0Seq).WillOnce(Return(true)); + + EXPECT_CALL(*mMockCal, getRedc(_)) + .InSequence(redcSeq) + .WillOnce(DoAll(SetArgReferee<0>(redcVal), Return(true))); + EXPECT_CALL(*mMockApi, setRedc(redcVal)).InSequence(redcSeq).WillOnce(Return(true)); + + EXPECT_CALL(*mMockCal, getQ(_)) + .InSequence(qSeq) + .WillOnce(DoAll(SetArgReferee<0>(qVal), Return(true))); + EXPECT_CALL(*mMockApi, setQ(qVal)).InSequence(qSeq).WillOnce(Return(true)); + + EXPECT_CALL(*mMockCal, getLongFrequencyShift(_)).WillOnce(Return(true)); + + mMockCal->getVersion(&calVer); + if (calVer == 2) { + volGet = EXPECT_CALL(*mMockCal, getTickVolLevels(_)).WillOnce(DoDefault()); + volGet = EXPECT_CALL(*mMockCal, getClickVolLevels(_)).WillOnce(DoDefault()); + volGet = EXPECT_CALL(*mMockCal, getLongVolLevels(_)).WillOnce(DoDefault()); + } + + EXPECT_CALL(*mMockCal, isF0CompEnabled()).WillOnce(Return(true)); + EXPECT_CALL(*mMockApi, setF0CompEnable(true)).WillOnce(Return(true)); + EXPECT_CALL(*mMockCal, isRedcCompEnabled()).WillOnce(Return(true)); + EXPECT_CALL(*mMockApi, setRedcCompEnable(true)).WillOnce(Return(true)); + + EXPECT_CALL(*mMockCal, isChirpEnabled()).WillOnce(Return(true)); + EXPECT_CALL(*mMockCal, getSupportedPrimitives(_)) + .InSequence(supportedPrimitivesSeq) + .WillOnce(DoAll(SetArgPointee<0>(supportedPrimitivesBits), Return(true))); + + EXPECT_CALL(*mMockApi, setMinOnOffInterval(MIN_ON_OFF_INTERVAL_US)).WillOnce(Return(true)); + EXPECT_CALL(*mMockApi, hasOwtFreeSpace()).WillOnce(Return(true)); + EXPECT_CALL(*mMockApi, getHapticAlsaDevice(_, _)).WillOnce(Return(true)); + EXPECT_CALL(*mMockApi, getContextScale()).WillRepeatedly(Return(0)); + EXPECT_CALL(*mMockApi, getContextEnable()).WillRepeatedly(Return(false)); + EXPECT_CALL(*mMockApi, getContextSettlingTime()).WillRepeatedly(Return(0)); + EXPECT_CALL(*mMockApi, getContextCooldownTime()).WillRepeatedly(Return(0)); + EXPECT_CALL(*mMockApi, getContextFadeEnable()).WillRepeatedly(Return(false)); + createVibrator(std::move(mockapi), std::move(mockcal), std::move(mockstats), false); +} + +TEST_F(VibratorTest, on) { + Sequence s1, s2; + uint16_t duration = std::rand() + 1; + + EXPECT_CALL(*mMockStats, logLatencyStart(kWaveformEffectLatency)) + .InSequence(s1, s2) + .WillOnce(DoDefault()); + EXPECT_CALL(*mMockApi, setFFGain(ON_GLOBAL_SCALE)).InSequence(s1).WillOnce(DoDefault()); + EXPECT_CALL(*mMockStats, logWaveform(_, _)).InSequence(s1).WillOnce(DoDefault()); + EXPECT_CALL(*mMockApi, setFFEffect(_, duration + MAX_COLD_START_LATENCY_MS)) + .InSequence(s2) + .WillOnce(DoDefault()); + EXPECT_CALL(*mMockStats, logLatencyEnd()).InSequence(s1, s2).WillOnce(DoDefault()); + EXPECT_CALL(*mMockApi, setFFPlay(ON_EFFECT_INDEX, true)) + .InSequence(s1, s2) + .WillOnce(DoDefault()); + EXPECT_TRUE(mVibrator->on(duration, nullptr).isOk()); +} + +TEST_F(VibratorTest, off) { + Sequence s1; + EXPECT_CALL(*mMockApi, setFFGain(ON_GLOBAL_SCALE)).InSequence(s1).WillOnce(DoDefault()); + EXPECT_TRUE(mVibrator->off().isOk()); +} + +TEST_F(VibratorTest, supportsAmplitudeControl_supported) { + int32_t capabilities; + EXPECT_CALL(*mMockApi, hasOwtFreeSpace()).WillOnce(Return(true)); + EXPECT_CALL(*mMockApi, getHapticAlsaDevice(_, _)).WillOnce(Return(true)); + + EXPECT_TRUE(mVibrator->getCapabilities(&capabilities).isOk()); + EXPECT_GT(capabilities & IVibrator::CAP_AMPLITUDE_CONTROL, 0); +} + +TEST_F(VibratorTest, supportsExternalAmplitudeControl_unsupported) { + int32_t capabilities; + EXPECT_CALL(*mMockApi, hasOwtFreeSpace()).WillOnce(Return(true)); + EXPECT_CALL(*mMockApi, getHapticAlsaDevice(_, _)).WillOnce(Return(true)); + + EXPECT_TRUE(mVibrator->getCapabilities(&capabilities).isOk()); + EXPECT_EQ(capabilities & IVibrator::CAP_EXTERNAL_AMPLITUDE_CONTROL, 0); +} + +TEST_F(VibratorTest, setAmplitude_supported) { + EffectAmplitude amplitude = static_cast<float>(std::rand()) / RAND_MAX ?: 1.0f; + + EXPECT_CALL(*mMockApi, setFFGain(amplitudeToScale(amplitude))).WillOnce(Return(true)); + + EXPECT_TRUE(mVibrator->setAmplitude(amplitude).isOk()); +} + +TEST_F(VibratorTest, supportsExternalControl_supported) { + int32_t capabilities; + EXPECT_CALL(*mMockApi, hasOwtFreeSpace()).WillOnce(Return(true)); + EXPECT_CALL(*mMockApi, getHapticAlsaDevice(_, _)).WillOnce(Return(true)); + + EXPECT_TRUE(mVibrator->getCapabilities(&capabilities).isOk()); + EXPECT_GT(capabilities & IVibrator::CAP_EXTERNAL_CONTROL, 0); +} + +TEST_F(VibratorTest, supportsExternalControl_unsupported) { + int32_t capabilities; + EXPECT_CALL(*mMockApi, hasOwtFreeSpace()).WillOnce(Return(true)); + EXPECT_CALL(*mMockApi, getHapticAlsaDevice(_, _)).WillOnce(Return(false)); + + EXPECT_TRUE(mVibrator->getCapabilities(&capabilities).isOk()); + EXPECT_EQ(capabilities & IVibrator::CAP_EXTERNAL_CONTROL, 0); +} + +TEST_F(VibratorTest, setExternalControl_enable) { + Sequence s1, s2; + EXPECT_CALL(*mMockApi, setFFGain(ON_GLOBAL_SCALE)).InSequence(s1).WillOnce(DoDefault()); + EXPECT_CALL(*mMockApi, getHapticAlsaDevice(_, _)).InSequence(s2).WillOnce(Return(true)); + EXPECT_CALL(*mMockApi, setHapticPcmAmp(_, true, _, _)) + .InSequence(s1, s2) + .WillOnce(Return(true)); + + EXPECT_TRUE(mVibrator->setExternalControl(true).isOk()); +} + +TEST_F(VibratorTest, setExternalControl_disable) { + Sequence s1, s2, s3, s4; + + // The default mIsUnderExternalControl is false, so it needs to turn on the External Control + // to make mIsUnderExternalControl become true. + EXPECT_CALL(*mMockApi, setFFGain(ON_GLOBAL_SCALE)) + .InSequence(s1) + .InSequence(s1) + .WillOnce(DoDefault()); + EXPECT_CALL(*mMockApi, getHapticAlsaDevice(_, _)).InSequence(s2).WillOnce(Return(true)); + EXPECT_CALL(*mMockApi, setHapticPcmAmp(_, true, _, _)).InSequence(s3).WillOnce(Return(true)); + + EXPECT_TRUE(mVibrator->setExternalControl(true).isOk()); + + EXPECT_CALL(*mMockApi, setFFGain(levelToScale(VOLTAGE_SCALE_MAX))) + .InSequence(s4) + .WillOnce(DoDefault()); + EXPECT_CALL(*mMockApi, setHapticPcmAmp(_, false, _, _)) + .InSequence(s1, s2, s3, s4) + .WillOnce(Return(true)); + + EXPECT_TRUE(mVibrator->setExternalControl(false).isOk()); +} + +class EffectsTest : public VibratorTest, public WithParamInterface<EffectTuple> { + public: + static auto PrintParam(const TestParamInfo<ParamType> &info) { + auto param = info.param; + auto effect = std::get<0>(param); + auto strength = std::get<1>(param); + return toString(effect) + "_" + toString(strength); + } +}; + +TEST_P(EffectsTest, perform) { + auto param = GetParam(); + auto effect = std::get<0>(param); + auto strength = std::get<1>(param); + auto scale = EFFECT_SCALE.find(param); + auto queue = EFFECT_QUEUE.find(param); + EffectDuration duration; + auto callback = ndk::SharedRefBase::make<MockVibratorCallback>(); + std::promise<void> promise; + std::future<void> future{promise.get_future()}; + auto complete = [&promise] { + promise.set_value(); + return ndk::ScopedAStatus::ok(); + }; + bool composeEffect; + + ExpectationSet eSetup; + Expectation eActivate, ePollHaptics, ePollStop, eEraseDone; + + eSetup += + EXPECT_CALL(*mMockStats, logLatencyStart(kPrebakedEffectLatency)).WillOnce(DoDefault()); + + if (scale != EFFECT_SCALE.end()) { + EffectIndex index = EFFECT_INDEX.at(effect); + duration = EFFECT_DURATIONS[index]; + + eSetup += EXPECT_CALL(*mMockApi, setFFGain(levelToScale(scale->second))) + .WillOnce(DoDefault()); + eSetup += EXPECT_CALL(*mMockStats, logLatencyEnd()).WillOnce(DoDefault()); + eActivate = + EXPECT_CALL(*mMockApi, setFFPlay(index, true)).After(eSetup).WillOnce(DoDefault()); + } else if (queue != EFFECT_QUEUE.end()) { + duration = std::get<1>(queue->second); + eSetup += EXPECT_CALL(*mMockApi, setFFGain(ON_GLOBAL_SCALE)) + .After(eSetup) + .WillOnce(DoDefault()); + eSetup += EXPECT_CALL(*mMockApi, getOwtFreeSpace(_)).WillOnce(DoDefault()); + eSetup += EXPECT_CALL(*mMockApi, uploadOwtEffect(_, _, _, _, _)) + .After(eSetup) + .WillOnce(DoDefault()); + eSetup += EXPECT_CALL(*mMockStats, logLatencyEnd()).After(eSetup).WillOnce(DoDefault()); + eActivate = EXPECT_CALL(*mMockApi, setFFPlay(WAVEFORM_COMPOSE, true)) + .After(eSetup) + .WillOnce(DoDefault()); + composeEffect = true; + } else { + duration = 0; + } + + if (duration) { + ePollHaptics = EXPECT_CALL(*mMockApi, pollVibeState(1, POLLING_TIMEOUT)) + .After(eActivate) + .WillOnce(DoDefault()); + ePollStop = EXPECT_CALL(*mMockApi, pollVibeState(0, -1)) + .After(ePollHaptics) + .WillOnce(DoDefault()); + if (composeEffect) { + eEraseDone = EXPECT_CALL(*mMockApi, eraseOwtEffect(_, _)) + .After(ePollStop) + .WillOnce(DoDefault()); + EXPECT_CALL(*callback, onComplete()).After(eEraseDone).WillOnce(complete); + } else { + EXPECT_CALL(*callback, onComplete()).After(ePollStop).WillOnce(complete); + } + } + + int32_t lengthMs; + ndk::ScopedAStatus status = mVibrator->perform(effect, strength, callback, &lengthMs); + if (status.isOk()) { + EXPECT_LE(duration, lengthMs); + } else { + EXPECT_EQ(EX_UNSUPPORTED_OPERATION, status.getExceptionCode()); + EXPECT_EQ(0, lengthMs); + } + + if (duration) { + EXPECT_EQ(future.wait_for(std::chrono::milliseconds(100)), std::future_status::ready); + } +} + +const std::vector<Effect> kEffects{ndk::enum_range<Effect>().begin(), + ndk::enum_range<Effect>().end()}; +const std::vector<EffectStrength> kEffectStrengths{ndk::enum_range<EffectStrength>().begin(), + ndk::enum_range<EffectStrength>().end()}; + +INSTANTIATE_TEST_CASE_P(VibratorTests, EffectsTest, + Combine(ValuesIn(kEffects.begin(), kEffects.end()), + ValuesIn(kEffectStrengths.begin(), kEffectStrengths.end())), + EffectsTest::PrintParam); + +struct PrimitiveParam { + CompositePrimitive primitive; + EffectIndex index; +}; + +class PrimitiveTest : public VibratorTest, public WithParamInterface<PrimitiveParam> { + public: + static auto PrintParam(const TestParamInfo<ParamType> &info) { + return toString(info.param.primitive); + } +}; + +const std::vector<PrimitiveParam> kPrimitiveParams = { + {CompositePrimitive::CLICK, 2}, {CompositePrimitive::THUD, 4}, + {CompositePrimitive::SPIN, 5}, {CompositePrimitive::QUICK_RISE, 6}, + {CompositePrimitive::SLOW_RISE, 7}, {CompositePrimitive::QUICK_FALL, 8}, + {CompositePrimitive::LIGHT_TICK, 9}, {CompositePrimitive::LOW_TICK, 10}, +}; + +TEST_P(PrimitiveTest, getPrimitiveDuration) { + auto param = GetParam(); + auto primitive = param.primitive; + auto index = param.index; + int32_t duration; + + EXPECT_EQ(EX_NONE, mVibrator->getPrimitiveDuration(primitive, &duration).getExceptionCode()); + EXPECT_EQ(EFFECT_DURATIONS[index], duration); +} + +INSTANTIATE_TEST_CASE_P(VibratorTests, PrimitiveTest, + ValuesIn(kPrimitiveParams.begin(), kPrimitiveParams.end()), + PrimitiveTest::PrintParam); + +struct ComposeParam { + std::string name; + std::vector<CompositeEffect> composite; + EffectQueue queue; +}; + +class ComposeTest : public VibratorTest, public WithParamInterface<ComposeParam> { + public: + static auto PrintParam(const TestParamInfo<ParamType> &info) { return info.param.name; } +}; + +TEST_P(ComposeTest, compose) { + auto param = GetParam(); + auto composite = param.composite; + auto queue = std::get<0>(param.queue); + ExpectationSet eSetup; + Expectation eActivate, ePollHaptics, ePollStop, eEraseDone; + auto callback = ndk::SharedRefBase::make<MockVibratorCallback>(); + std::promise<void> promise; + std::future<void> future{promise.get_future()}; + auto complete = [&promise] { + promise.set_value(); + return ndk::ScopedAStatus::ok(); + }; + + eSetup += EXPECT_CALL(*mMockStats, logLatencyStart(kCompositionEffectLatency)) + .WillOnce(DoDefault()); + for (auto &primitive : composite) { + eSetup += EXPECT_CALL(*mMockStats, logPrimitive(_)).After(eSetup).WillOnce(DoDefault()); + } + eSetup += + EXPECT_CALL(*mMockApi, setFFGain(ON_GLOBAL_SCALE)).After(eSetup).WillOnce(DoDefault()); + eSetup += EXPECT_CALL(*mMockApi, getOwtFreeSpace(_)).WillOnce(DoDefault()); + eSetup += EXPECT_CALL(*mMockApi, uploadOwtEffect(_, _, _, _, _)) + .After(eSetup) + .WillOnce(DoDefault()); + eSetup += EXPECT_CALL(*mMockStats, logLatencyEnd()).WillOnce(DoDefault()); + eActivate = EXPECT_CALL(*mMockApi, setFFPlay(WAVEFORM_COMPOSE, true)) + .After(eSetup) + .WillOnce(DoDefault()); + + ePollHaptics = EXPECT_CALL(*mMockApi, pollVibeState(1, POLLING_TIMEOUT)) + .After(eActivate) + .WillOnce(DoDefault()); + ePollStop = + EXPECT_CALL(*mMockApi, pollVibeState(0, -1)).After(ePollHaptics).WillOnce(DoDefault()); + eEraseDone = + EXPECT_CALL(*mMockApi, eraseOwtEffect(_, _)).After(ePollStop).WillOnce(DoDefault()); + EXPECT_CALL(*callback, onComplete()).After(eEraseDone).WillOnce(complete); + + EXPECT_EQ(EX_NONE, mVibrator->compose(composite, callback).getExceptionCode()); + + EXPECT_EQ(future.wait_for(std::chrono::milliseconds(100)), std::future_status::ready); +} + +const std::vector<ComposeParam> kComposeParams = { + {"click", + {{0, CompositePrimitive::CLICK, 1.0f}}, + Queue(QueueEffect(2, Level(1.0f, V_CLICK_DEFAULT[0], V_CLICK_DEFAULT[1])), 0)}, + {"thud", + {{1, CompositePrimitive::THUD, 0.8f}}, + Queue(1, QueueEffect(4, Level(0.8f, V_CLICK_DEFAULT[0], V_CLICK_DEFAULT[1])), 0)}, + {"spin", + {{2, CompositePrimitive::SPIN, 0.6f}}, + Queue(2, QueueEffect(5, Level(0.6f, V_CLICK_DEFAULT[0], V_CLICK_DEFAULT[1])), 0)}, + {"quick_rise", + {{3, CompositePrimitive::QUICK_RISE, 0.4f}}, + Queue(3, QueueEffect(6, Level(0.4f, V_LONG_DEFAULT[0], V_LONG_DEFAULT[1])), 0)}, + {"slow_rise", + {{4, CompositePrimitive::SLOW_RISE, 0.0f}}, + Queue(4, QueueEffect(7, Level(0.0f, V_CLICK_DEFAULT[0], V_CLICK_DEFAULT[1])), 0)}, + {"quick_fall", + {{5, CompositePrimitive::QUICK_FALL, 1.0f}}, + Queue(5, QueueEffect(8, Level(1.0f, V_LONG_DEFAULT[0], V_LONG_DEFAULT[1])), 0)}, + {"pop", + {{6, CompositePrimitive::SLOW_RISE, 1.0f}, {50, CompositePrimitive::THUD, 1.0f}}, + Queue(6, QueueEffect(7, Level(1.0f, V_CLICK_DEFAULT[0], V_CLICK_DEFAULT[1])), 50, + QueueEffect(4, Level(1.0f, V_CLICK_DEFAULT[0], V_CLICK_DEFAULT[1])), 0)}, + {"snap", + {{7, CompositePrimitive::QUICK_RISE, 1.0f}, {0, CompositePrimitive::QUICK_FALL, 1.0f}}, + Queue(7, QueueEffect(6, Level(1.0f, V_LONG_DEFAULT[0], V_LONG_DEFAULT[1])), + QueueEffect(8, Level(1.0f, V_LONG_DEFAULT[0], V_LONG_DEFAULT[1])), 0)}, +}; + +INSTANTIATE_TEST_CASE_P(VibratorTests, ComposeTest, + ValuesIn(kComposeParams.begin(), kComposeParams.end()), + ComposeTest::PrintParam); +} // namespace vibrator +} // namespace hardware +} // namespace android +} // namespace aidl diff --git a/vibrator/cs40l26/tests/types.h b/vibrator/cs40l26/tests/types.h new file mode 100644 index 00000000..e05c648e --- /dev/null +++ b/vibrator/cs40l26/tests/types.h @@ -0,0 +1,33 @@ +/* + * Copyright (C) 2022 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. + */ +#ifndef ANDROID_HARDWARE_VIBRATOR_TEST_TYPES_H +#define ANDROID_HARDWARE_VIBRATOR_TEST_TYPES_H + +#include <aidl/android/hardware/vibrator/IVibrator.h> + +using EffectIndex = uint16_t; +using EffectLevel = uint32_t; +using EffectAmplitude = float; +using EffectScale = uint16_t; +using EffectDuration = uint32_t; +using EffectQueue = std::tuple<std::string, EffectDuration>; +using EffectTuple = std::tuple<::aidl::android::hardware::vibrator::Effect, + ::aidl::android::hardware::vibrator::EffectStrength>; + +using QueueEffect = std::tuple<EffectIndex, EffectLevel>; +using QueueDelay = uint32_t; + +#endif // ANDROID_HARDWARE_VIBRATOR_TEST_TYPES_H diff --git a/vibrator/cs40l26/tests/utils.h b/vibrator/cs40l26/tests/utils.h new file mode 100644 index 00000000..e7f6055c --- /dev/null +++ b/vibrator/cs40l26/tests/utils.h @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2022 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. + */ +#ifndef ANDROID_HARDWARE_VIBRATOR_TEST_UTILS_H +#define ANDROID_HARDWARE_VIBRATOR_TEST_UTILS_H + +#include <cmath> + +#include "types.h" + +static inline EffectScale toScale(float amplitude, float maximum) { + float ratio = 100; /* Unit: % */ + if (maximum != 0) + ratio = amplitude / maximum * 100; + + if (maximum == 0 || ratio > 100) + ratio = 100; + + return std::round(ratio); +} + +static inline EffectScale levelToScale(EffectLevel level) { + return toScale(level, 100); +} + +static inline EffectScale amplitudeToScale(EffectAmplitude amplitude) { + return toScale(amplitude, 1.0f); +} + +static inline uint32_t msToCycles(EffectDuration ms) { + return ms * 48; +} + +#endif // ANDROID_HARDWARE_VIBRATOR_TEST_UTILS_H diff --git a/vibrator/drv2624/Android.bp b/vibrator/drv2624/Android.bp index ef792a39..508b82bf 100644 --- a/vibrator/drv2624/Android.bp +++ b/vibrator/drv2624/Android.bp @@ -21,7 +21,7 @@ cc_defaults { name: "android.hardware.vibrator-defaults.drv2624", cflags: [ "-DATRACE_TAG=(ATRACE_TAG_VIBRATOR | ATRACE_TAG_HAL)", - "-DLOG_TAG=\"android.hardware.vibrator-drv2624\"", + "-DLOG_TAG=\"Vibrator\"", ], } diff --git a/wifi_ext/device.mk b/wifi_ext/device.mk index b9917401..cffd0657 100644 --- a/wifi_ext/device.mk +++ b/wifi_ext/device.mk @@ -1,2 +1,2 @@ -PRODUCT_PACKAGES += vendor.google.wifi_ext@1.0-service-vendor +PRODUCT_PACKAGES += com.google.pixel.wifi.ext BOARD_VENDOR_SEPOLICY_DIRS += hardware/google/pixel-sepolicy/wifi_ext |