Line data    Source code

       1              : /**
       2              :  * Copyright (c) 2025 Huawei Technologies Co., Ltd.
       3              :  * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
       4              :  * CANN Open Software License Agreement Version 2.0 (the "License").
       5              :  * Please refer to the License for details. You may not use this file except in compliance with the License.
       6              :  * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
       7              :  * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
       8              :  * See LICENSE in the root of the software repository for the full text of the License.
       9              :  */
      10              : #include "aicpusd_monitor.h"
      11              : #include "aicpusd_status.h"
      12              : #include <stdio.h>
      13              : 
      14              : namespace AicpuSchedule {
      15              : /**
      16              :  * @ingroup AicpuMonitor
      17              :  * @brief it is used to construct a object of AicpuMonitor.
      18              :  */
      19            0 : AicpuMonitor::AicpuMonitor()
      20            0 :     : deviceId_(0),
      21            0 :       taskTimeoutFlag_(false),
      22            0 :       modelTimeoutFlag_(false),
      23            0 :       done_(false),
      24            0 :       taskTimeout_(UINT64_MAX),
      25            0 :       taskTimeoutTick_(UINT64_MAX),
      26            0 :       modelTimeoutTick_(UINT64_MAX),
      27            0 :       aicpuTaskTimer_(nullptr),
      28            0 :       modelTimer_(nullptr),
      29            0 :       running_(false),
      30            0 :       aicpuCoreNum_(0),
      31            0 :       online_(false),
      32            0 :       opTimeoutFlag_(false)
      33            0 : {}
      34              : 
      35              : /**
      36              :  * @ingroup AicpuMonitor
      37              :  * @brief it is used to destructor a object of AicpuMonitor.
      38              :  */
      39            0 : AicpuMonitor::~AicpuMonitor() {}
      40              : 
      41            0 : AicpuMonitor &AicpuMonitor::GetInstance()
      42              : {
      43            0 :     static AicpuMonitor instance;
      44            0 :     return instance;
      45              : }
      46              : 
      47            0 : int32_t AicpuMonitor::InitMonitor(const uint32_t deviceId, const bool online)
      48              : {
      49              :     UNUSED(deviceId);
      50              :     UNUSED(online);
      51            0 :     return AICPU_SCHEDULE_OK;
      52              : }
      53              : 
      54            0 : void AicpuMonitor::SendKillMsgToTsd() const
      55              : {
      56            0 :     return;
      57              : }
      58              : 
      59            0 : void AicpuMonitor::SetTaskInfo(const uint32_t threadIndex, const TaskInfoForMonitor &taskInfo) const
      60              : {
      61              :     UNUSED(threadIndex);
      62              :     UNUSED(taskInfo);
      63            0 :     return;
      64              : }
      65              : 
      66            0 : void AicpuMonitor::SetOpExecuteTimeOut(const uint32_t timeOutEn, const uint32_t opExecuteTimeOut)
      67              : {
      68              :     UNUSED(timeOutEn);
      69              :     UNUSED(opExecuteTimeOut);
      70            0 :     return;
      71              : }
      72              : 
      73            0 : void AicpuMonitor::SetTaskStartTime(const uint32_t index) 
      74              : {
      75              :     UNUSED(index);
      76            0 : }
      77              : 
      78            0 : void AicpuMonitor::SetTaskEndTime(const uint32_t index) 
      79              : {
      80              :     UNUSED(index);
      81            0 : }
      82              : 
      83            0 : void AicpuMonitor::SetAicpuStreamTaskStartTime(const uint32_t taskId) 
      84              : {
      85              :     UNUSED(taskId);
      86            0 : }
      87              : 
      88            0 : void AicpuMonitor::SetAicpuStreamTaskEndTime(const uint32_t taskId) 
      89              : {
      90              :     UNUSED(taskId);
      91            0 : }
      92              : 
      93            0 : void AicpuMonitor::SetModelStartTime(const uint32_t modelId) 
      94              : {
      95              :     UNUSED(modelId);
      96            0 : }
      97              : 
      98            0 : void AicpuMonitor::SetModelEndTime(const uint32_t modelId) 
      99              : {
     100              :     UNUSED(modelId);
     101            0 : }
     102              : 
     103            0 : int32_t AicpuMonitor::Run()
     104              : {
     105            0 :     return AICPU_SCHEDULE_OK;
     106              : }
     107              : 
     108            0 : void AicpuMonitor::StopMonitor() {}
     109              : 
     110            0 : int32_t AicpuMonitor::SetTaskTimeoutFlag()
     111              : {
     112            0 :     return AICPU_SCHEDULE_OK;
     113              : }
     114              : 
     115            0 : int32_t AicpuMonitor::SetModelTimeoutFlag()
     116              : {
     117            0 :     return AICPU_SCHEDULE_OK;
     118              : }
     119              : 
     120            0 : void AicpuMonitor::Work(AicpuMonitor *monitor) 
     121              : {
     122              :     UNUSED(monitor);
     123            0 : }
     124              : 
     125            0 : void AicpuMonitor::HandleTaskTimeout() {}
     126              : 
     127            0 : void AicpuMonitor::HandleModelTimeout() {}
     128              : 
     129            0 : void AicpuMonitor::DisableModelTimeout() {}
     130              : 
     131            0 : void AicpuMonitor::SetOpTimerStartTime(const aicpu::TimerHandle timerId, const uint32_t timeInS) 
     132              : {
     133              :     UNUSED(timerId);
     134              :     UNUSED(timeInS);
     135            0 : }
     136              : 
     137            0 : void AicpuMonitor::SetOpTimerEndTime(const aicpu::TimerHandle timerId) 
     138              : {
     139              :     UNUSED(timerId);
     140            0 : }
     141              : 
     142            0 : void AicpuMonitor::HandleOpTimeout() {}
     143              : 
     144            0 : void AicpuMonitor::InitAsyncOpTimer() {}
     145              : 
     146            0 : uint32_t AicpuMonitor::GetTaskDefaultTimeout() const
     147              : {
     148            0 :     return 0U;
     149              : }
     150              : 
     151            0 : void AicpuMonitor::SetOpTimeoutFlag(const bool flag) 
     152              : {
     153              :     UNUSED(flag);
     154            0 : }
     155              : }