1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
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 "parallel_task_dispatcher.h"
16 #include "app_log_wrapper.h"
17
18 namespace OHOS {
19 namespace AppExecFwk {
20 const std::string ParallelTaskDispatcher::DISPATCHER_TAG = "ParallelTaskDispatcher";
21 const std::string ParallelTaskDispatcher::ASYNC_DISPATCHER_BARRIER_TAG = DISPATCHER_TAG + "::asyncDispatchBarrier";
22 const std::string ParallelTaskDispatcher::SYNC_DISPATCHER_BARRIER_TAG = DISPATCHER_TAG + "::syncDispatchBarrier";
ParallelTaskDispatcher(const std::string & name,TaskPriority priority,std::shared_ptr<TaskExecutor> & executor)23 ParallelTaskDispatcher::ParallelTaskDispatcher(
24 const std::string &name, TaskPriority priority, std::shared_ptr<TaskExecutor> &executor)
25 : ParallelTaskDispatcherBase(priority, executor, name)
26 {
27 barrierHandler_ = std::make_shared<BarrierHandler>(executor);
28 }
29
GetInterceptor()30 std::shared_ptr<TaskExecuteInterceptor> ParallelTaskDispatcher::GetInterceptor()
31 {
32 return barrierHandler_;
33 }
34
SyncDispatchBarrier(const std::shared_ptr<Runnable> & runnable)35 ErrCode ParallelTaskDispatcher::SyncDispatchBarrier(const std::shared_ptr<Runnable> &runnable)
36 {
37 APP_LOGI("ParallelTaskDispatcher::SyncDispatchBarrier start");
38 if (Check(runnable) != ERR_OK) {
39 APP_LOGE("ParallelTaskDispatcher::SyncDispatchBarrier Check failed");
40 return ERR_APPEXECFWK_CHECK_FAILED;
41 }
42
43 std::shared_ptr<SyncTask> innerSyncTask = std::make_shared<SyncTask>(runnable, GetPriority(), shared_from_this());
44 if (innerSyncTask == nullptr) {
45 APP_LOGE("ParallelTaskDispatcher::SyncDispatchBarrier innerSyncTask is nullptr");
46 return ERR_APPEXECFWK_CHECK_FAILED;
47 }
48 std::shared_ptr<Task> innerTask = std::static_pointer_cast<Task>(innerSyncTask);
49 if (innerTask == nullptr) {
50 APP_LOGE("ParallelTaskDispatcher::SyncDispatchBarrier innerTask is nullptr");
51 return ERR_APPEXECFWK_CHECK_FAILED;
52 }
53 APP_LOGD("ParallelTaskDispatcher::SyncDispatchBarrier into new sync task");
54 if (barrierHandler_ == nullptr) {
55 APP_LOGE("ParallelTaskDispatcher::SyncDispatchBarrier barrierHandler_ is nullptr");
56 return ERR_APPEXECFWK_CHECK_FAILED;
57 }
58 barrierHandler_->AddBarrier(innerTask);
59 innerSyncTask->WaitTask();
60 APP_LOGD("ParallelTaskDispatcher::SyncDispatchBarrier end");
61 return ERR_OK;
62 }
63
AsyncDispatchBarrier(const std::shared_ptr<Runnable> & runnable)64 ErrCode ParallelTaskDispatcher::AsyncDispatchBarrier(const std::shared_ptr<Runnable> &runnable)
65 {
66 APP_LOGI("ParallelTaskDispatcher::AsyncDispatchBarrier start");
67 if (Check(runnable) != ERR_OK) {
68 APP_LOGE("ParallelTaskDispatcher::AsyncDispatchBarrier check failed");
69 return ERR_APPEXECFWK_CHECK_FAILED;
70 }
71 if (barrierHandler_ == nullptr) {
72 APP_LOGE("ParallelTaskDispatcher::AsyncDispatchBarrier barrierHandler_ is nullptr");
73 return ERR_APPEXECFWK_CHECK_FAILED;
74 }
75 std::shared_ptr<Task> innerTask = std::make_shared<Task>(runnable, GetPriority(), shared_from_this());
76 APP_LOGI("ParallelTaskDispatcher::AsyncDispatchBarrier into new async task");
77 if (innerTask == nullptr) {
78 APP_LOGE("ParallelTaskDispatcher::AsyncDispatchBarrier innerTask is nullptr");
79 return ERR_APPEXECFWK_CHECK_FAILED;
80 }
81
82 barrierHandler_->AddBarrier(innerTask);
83 APP_LOGI("ParallelTaskDispatcher::AsyncDispatchBarrier end");
84 return ERR_OK;
85 }
86
87 } // namespace AppExecFwk
88 } // namespace OHOS