1 /*
2 * Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "task_pool_stdtype.h"
16
17 namespace SysTuning {
18 namespace TraceStdtype {
AppendAllocationTaskData(uint32_t allocationTaskRow,uint32_t allocationItid,uint64_t taskId,uint32_t priority,uint32_t executeState)19 size_t TaskPoolInfo::AppendAllocationTaskData(uint32_t allocationTaskRow,
20 uint32_t allocationItid,
21 uint64_t taskId,
22 uint32_t priority,
23 uint32_t executeState)
24 {
25 allocationTaskRows_.emplace_back(allocationTaskRow);
26 executeTaskRows_.emplace_back(INVALID_INT32);
27 returnTaskRows_.emplace_back(INVALID_INT32);
28 allocationItids_.emplace_back(allocationItid);
29 executeItids_.emplace_back(INVALID_INT32);
30 returnItids_.emplace_back(INVALID_INT32);
31 taskIds_.emplace_back(taskId);
32 prioritys_.emplace_back(priority);
33 executeStates_.emplace_back(executeState);
34 returnStates_.emplace_back(INVALID_INT32);
35 timeoutRows_.emplace_back(INVALID_INT32);
36 ids_.emplace_back(Size());
37 return Size() - 1;
38 }
AppendExecuteTaskData(uint32_t executeTaskRow,uint32_t executeItid,uint64_t taskId)39 size_t TaskPoolInfo::AppendExecuteTaskData(uint32_t executeTaskRow, uint32_t executeItid, uint64_t taskId)
40 {
41 allocationTaskRows_.emplace_back(INVALID_INT32);
42 executeTaskRows_.emplace_back(executeTaskRow);
43 returnTaskRows_.emplace_back(INVALID_INT32);
44 allocationItids_.emplace_back(INVALID_INT32);
45 executeItids_.emplace_back(executeItid);
46 returnItids_.emplace_back(INVALID_INT32);
47 taskIds_.emplace_back(taskId);
48 prioritys_.emplace_back(INVALID_INT32);
49 executeStates_.emplace_back(INVALID_INT32);
50 returnStates_.emplace_back(INVALID_INT32);
51 timeoutRows_.emplace_back(INVALID_INT32);
52 ids_.emplace_back(Size());
53 return Size() - 1;
54 }
AppendReturnTaskData(uint32_t returnTaskRow,uint32_t returnItid,uint64_t taskId,uint32_t returnState)55 size_t TaskPoolInfo::AppendReturnTaskData(uint32_t returnTaskRow,
56 uint32_t returnItid,
57 uint64_t taskId,
58 uint32_t returnState)
59 {
60 allocationTaskRows_.emplace_back(INVALID_INT32);
61 executeTaskRows_.emplace_back(INVALID_INT32);
62 returnTaskRows_.emplace_back(returnTaskRow);
63 allocationItids_.emplace_back(INVALID_INT32);
64 executeItids_.emplace_back(INVALID_INT32);
65 returnItids_.emplace_back(returnItid);
66 taskIds_.emplace_back(taskId);
67 prioritys_.emplace_back(INVALID_INT32);
68 executeStates_.emplace_back(INVALID_INT32);
69 returnStates_.emplace_back(returnState);
70 timeoutRows_.emplace_back(INVALID_INT32);
71 ids_.emplace_back(Size());
72 return Size() - 1;
73 }
AllocationTaskRows() const74 const std::deque<uint32_t> &TaskPoolInfo::AllocationTaskRows() const
75 {
76 return allocationTaskRows_;
77 }
ExecuteTaskRows() const78 const std::deque<uint32_t> &TaskPoolInfo::ExecuteTaskRows() const
79 {
80 return executeTaskRows_;
81 }
ReturnTaskRows() const82 const std::deque<uint32_t> &TaskPoolInfo::ReturnTaskRows() const
83 {
84 return returnTaskRows_;
85 }
AllocationItids() const86 const std::deque<uint32_t> &TaskPoolInfo::AllocationItids() const
87 {
88 return allocationItids_;
89 }
ExecuteItids() const90 const std::deque<uint32_t> &TaskPoolInfo::ExecuteItids() const
91 {
92 return executeItids_;
93 }
ReturnItids() const94 const std::deque<uint32_t> &TaskPoolInfo::ReturnItids() const
95 {
96 return returnItids_;
97 }
TaskIds() const98 const std::deque<uint64_t> &TaskPoolInfo::TaskIds() const
99 {
100 return taskIds_;
101 }
Prioritys() const102 const std::deque<uint32_t> &TaskPoolInfo::Prioritys() const
103 {
104 return prioritys_;
105 }
ExecuteStates() const106 const std::deque<uint32_t> &TaskPoolInfo::ExecuteStates() const
107 {
108 return executeStates_;
109 }
ReturnStates() const110 const std::deque<uint32_t> &TaskPoolInfo::ReturnStates() const
111 {
112 return returnStates_;
113 }
TimeoutRows() const114 const std::deque<uint32_t> &TaskPoolInfo::TimeoutRows() const
115 {
116 return timeoutRows_;
117 }
UpdateAllocationTaskData(uint32_t index,uint32_t allocationTaskRow,uint32_t allocationItid,uint32_t priority,uint32_t executeState)118 void TaskPoolInfo::UpdateAllocationTaskData(uint32_t index,
119 uint32_t allocationTaskRow,
120 uint32_t allocationItid,
121 uint32_t priority,
122 uint32_t executeState)
123 {
124 if (index <= Size()) {
125 allocationTaskRows_[index] = allocationTaskRow;
126 allocationItids_[index] = allocationItid;
127 prioritys_[index] = priority;
128 executeStates_[index] = executeState;
129 }
130 }
UpdateExecuteTaskData(uint32_t index,uint32_t executeTaskRow,uint64_t executeItid)131 void TaskPoolInfo::UpdateExecuteTaskData(uint32_t index, uint32_t executeTaskRow, uint64_t executeItid)
132 {
133 if (index <= Size()) {
134 executeTaskRows_[index] = executeTaskRow;
135 executeItids_[index] = executeItid;
136 }
137 }
UpdateReturnTaskData(uint32_t index,uint32_t returnTaskRow,uint32_t returnItid,uint32_t returnState)138 void TaskPoolInfo::UpdateReturnTaskData(uint32_t index,
139 uint32_t returnTaskRow,
140 uint32_t returnItid,
141 uint32_t returnState)
142 {
143 if (index <= Size()) {
144 returnTaskRows_[index] = returnTaskRow;
145 returnItids_[index] = returnItid;
146 returnStates_[index] = returnState;
147 }
148 }
AppendTimeoutRow(uint32_t index,uint32_t timeoutRow)149 void TaskPoolInfo::AppendTimeoutRow(uint32_t index, uint32_t timeoutRow)
150 {
151 if (index <= Size()) {
152 timeoutRows_[index] = timeoutRow;
153 }
154 }
155 } // namespace TraceStdtype
156 } // namespace SysTuning
157