[Hexagon] Add power manager

src/runtime/hexagon/hexagon_common.h

@@ -41,6 +41,7 @@
     int result = api_call;                                                        \
     if (result != 0) {                                                            \
       HEXAGON_PRINT(ERROR, "ERROR: " #api_call " failed with error %d.", result); \
+      abort();                                                                    \
     }                                                                             \
   } while (0)
 

src/runtime/hexagon/hexagon_device_api.h

@@ -31,6 +31,7 @@
 
 #include "hexagon_buffer.h"
 #include "hexagon_buffer_manager.h"
+#include "hexagon_power_manager.h"
 #include "hexagon_thread_manager.h"
 #include "hexagon_user_dma.h"
 #include "hexagon_vtcm_pool.h"
@@ -55,6 +56,9 @@ class HexagonDeviceAPI final : public DeviceAPI {
 
   //! \brief Ensures resource managers are in a good state for the runtime
   void AcquireResources() {
+    CHECK_EQ(runtime_power_manager, nullptr);
+    runtime_power_manager = std::make_unique<HexagonPowerManager>();
+
     CHECK_EQ(runtime_vtcm, nullptr);
     runtime_vtcm = std::make_unique<HexagonVtcmPool>();
 
@@ -81,6 +85,9 @@ class HexagonDeviceAPI final : public DeviceAPI {
 
     CHECK(runtime_vtcm) << "runtime_vtcm was not created in AcquireResources";
     runtime_vtcm.reset();
+
+    CHECK(runtime_power_manager) << "runtime_power_manager was not created in AcquireResources";
+    runtime_power_manager.reset();
   }
 
   /*! \brief Currently unimplemented interface to specify the active
@@ -202,6 +209,9 @@ class HexagonDeviceAPI final : public DeviceAPI {
 
   //! \brief VTCM memory manager
   std::unique_ptr<HexagonVtcmPool> runtime_vtcm;
+
+  //! \brief Hexagon power manager
+  std::unique_ptr<HexagonPowerManager> runtime_power_manager;
 };
 }  // namespace hexagon
 }  // namespace runtime

src/runtime/hexagon/hexagon_htp.cc

@@ -35,39 +35,9 @@ namespace tvm {
 namespace runtime {
 namespace hexagon {
 
-HexagonHtp::HexagonHtp() {
-  PowerOn();
-  Acquire();
-}
-
-HexagonHtp::~HexagonHtp() {
-  Release();
-  PowerOff();
-}
-
-void HexagonHtp::PowerOn() {
-  HAP_power_request_t pwr_req;
-  int nErr;
-
-  hap_pwr_ctx_ = HAP_utils_create_context();
-  pwr_req.type = HAP_power_set_HMX;
-  pwr_req.hmx.power_up = true;
-  if ((nErr = HAP_power_set(hap_pwr_ctx_, &pwr_req))) {
-    LOG(FATAL) << "InternalError: HAP_power_set failed\n";
-  }
-}
-
-void HexagonHtp::PowerOff() {
-  HAP_power_request_t pwr_req;
-  int nErr;
+HexagonHtp::HexagonHtp() { Acquire(); }
 
-  pwr_req.type = HAP_power_set_HMX;
-  pwr_req.hmx.power_up = false;
-  if ((nErr = HAP_power_set(hap_pwr_ctx_, &pwr_req))) {
-    LOG(FATAL) << "InternalError: HAP_power_set failed\n";
-  }
-  HAP_utils_destroy_context(hap_pwr_ctx_);
-}
+HexagonHtp::~HexagonHtp() { Release(); }
 
 void HexagonHtp::Acquire() {
   compute_res_attr_t compute_res_attr;

src/runtime/hexagon/hexagon_htp.h

@@ -45,14 +45,9 @@ class HexagonHtp {
   HexagonHtp& operator=(HexagonHtp&&) = delete;
 
  private:
-  //! \brief Power context
-  void* hap_pwr_ctx_;
-
   //! \brief Acquisition context ID
   unsigned int context_id_;
 
-  void PowerOn();
-  void PowerOff();
   void Acquire();
   void Release();
 };

src/runtime/hexagon/hexagon_power_manager.cc

@@ -0,0 +1,108 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 "hexagon_power_manager.h"
+
+#include <AEEStdDef.h>
+#include <AEEStdErr.h>
+
+#include "HAP_power.h"
+#include "hexagon_common.h"
+
+namespace tvm {
+namespace runtime {
+namespace hexagon {
+
+HexagonPowerManager::HexagonPowerManager() {
+  hap_pwr_ctx_ = HAP_utils_create_context();
+  PowerOnHVX();
+  PowerOnHTP();
+  SetAppType();
+  SetDCVS();
+}
+
+HexagonPowerManager::~HexagonPowerManager() {
+  PowerOffHTP();
+  PowerOffHVX();
+  HAP_utils_destroy_context(hap_pwr_ctx_);
+}
+
+void HexagonPowerManager::PowerOnHVX() {
+  HAP_power_request_t pwr_req;
+
+  pwr_req.type = HAP_power_set_HVX;
+  pwr_req.hvx.power_up = true;
+  HEXAGON_SAFE_CALL(HAP_power_set(hap_pwr_ctx_, &pwr_req));
+}
+
+void HexagonPowerManager::PowerOffHVX() {
+  HAP_power_request_t pwr_req;
+
+  pwr_req.type = HAP_power_set_HVX;
+  pwr_req.hvx.power_up = false;
+  HEXAGON_SAFE_CALL(HAP_power_set(hap_pwr_ctx_, &pwr_req));
+}
+
+void HexagonPowerManager::PowerOnHTP() {
+  HAP_power_request_t pwr_req;
+
+  pwr_req.type = HAP_power_set_HMX;
+  pwr_req.hmx.power_up = true;
+  HEXAGON_SAFE_CALL(HAP_power_set(hap_pwr_ctx_, &pwr_req));
+}
+
+void HexagonPowerManager::PowerOffHTP() {
+  HAP_power_request_t pwr_req;
+
+  pwr_req.type = HAP_power_set_HMX;
+  pwr_req.hmx.power_up = false;
+  HEXAGON_SAFE_CALL(HAP_power_set(hap_pwr_ctx_, &pwr_req));
+}
+
+void HexagonPowerManager::SetAppType() {
+  HAP_power_request_t pwr_req;
+
+  pwr_req.type = HAP_power_set_apptype;
+  pwr_req.apptype = HAP_POWER_COMPUTE_CLIENT_CLASS;
+  HEXAGON_SAFE_CALL(HAP_power_set(hap_pwr_ctx_, &pwr_req));
+}
+
+void HexagonPowerManager::SetDCVS() {
+  HAP_power_request_t pwr_req;
+
+  memset(&pwr_req, 0, sizeof(HAP_power_request_t));
+  pwr_req.type = HAP_power_set_DCVS_v3;
+  pwr_req.dcvs_v3.set_dcvs_enable = TRUE;
+  pwr_req.dcvs_v3.dcvs_enable = FALSE;
+  pwr_req.dcvs_v3.set_core_params = TRUE;
+  pwr_req.dcvs_v3.core_params.min_corner = HAP_DCVS_VCORNER_TURBO_PLUS;
+  pwr_req.dcvs_v3.core_params.max_corner = HAP_DCVS_VCORNER_TURBO_PLUS;
+  pwr_req.dcvs_v3.core_params.target_corner = HAP_DCVS_VCORNER_TURBO_PLUS;
+  pwr_req.dcvs_v3.set_bus_params = TRUE;
+  pwr_req.dcvs_v3.bus_params.min_corner = HAP_DCVS_VCORNER_TURBO_PLUS;
+  pwr_req.dcvs_v3.bus_params.max_corner = HAP_DCVS_VCORNER_TURBO_PLUS;
+  pwr_req.dcvs_v3.bus_params.target_corner = HAP_DCVS_VCORNER_TURBO_PLUS;
+  pwr_req.dcvs_v3.set_sleep_disable = TRUE;
+  pwr_req.dcvs_v3.sleep_disable = TRUE;
+  HEXAGON_SAFE_CALL(HAP_power_set(hap_pwr_ctx_, &pwr_req));
+}
+
+}  // namespace hexagon
+}  // namespace runtime
+}  // namespace tvm

src/runtime/hexagon/hexagon_power_manager.h

@@ -0,0 +1,63 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 TVM_RUNTIME_HEXAGON_HEXAGON_POWER_MANAGER_H_
+#define TVM_RUNTIME_HEXAGON_HEXAGON_POWER_MANAGER_H_
+
+namespace tvm {
+namespace runtime {
+namespace hexagon {
+
+class HexagonPowerManager {
+ public:
+  //! \brief Constructor.
+  HexagonPowerManager();
+
+  //! \brief Destructor.
+  ~HexagonPowerManager();
+
+  //! \brief Prevent copy construction of HexagonPowerManager.
+  HexagonPowerManager(const HexagonPowerManager&) = delete;
+
+  //! \brief Prevent copy assignment with HexagonPowerManager.
+  HexagonPowerManager& operator=(const HexagonPowerManager&) = delete;
+
+  //! \brief Prevent move construction.
+  HexagonPowerManager(HexagonPowerManager&&) = delete;
+
+  //! \brief Prevent move assignment.
+  HexagonPowerManager& operator=(HexagonPowerManager&&) = delete;
+
+ private:
+  //! \brief Power context
+  void* hap_pwr_ctx_;
+
+  void PowerOnHVX();
+  void PowerOffHVX();
+  void PowerOnHTP();
+  void PowerOffHTP();
+  void SetAppType();
+  void SetDCVS();
+};
+
+}  // namespace hexagon
+}  // namespace runtime
+}  // namespace tvm
+
+#endif  // TVM_RUNTIME_HEXAGON_HEXAGON_POWER_MANAGER_H_