1// Copyright 2016 The Gemmlowp Authors. All Rights Reserved.
2//
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#ifndef GEMMLOWP_META_MULTI_THREAD_TRANSFORM_H_
16#define GEMMLOWP_META_MULTI_THREAD_TRANSFORM_H_
17
18#include "multi_thread_common.h"
19#include "single_thread_transform.h"
20
21namespace gemmlowp {
22namespace meta {
23namespace internal {
24
25const int kTransformTaskOverhead = 128000;
26const int kMinTransformTaskSize = 32000;
27
28template <typename MultiThreadingContext, typename Params>
29inline bool PrepareTransform1DTasks(MultiThreadingContext* context,
30 const Params& params, int kernel_size,
31 std::vector<Params>* task_params) {
32 typedef Transform1DUtil<typename Params::InType, typename Params::OutType,
33 typename Params::Kernel>
34 Util;
35
36 const int max_threads = ResolveMaxThreads(context->max_num_threads());
37 const int task_size = Util::EstimateComputeCost(params.kernel);
38 const int max_tasks_by_size =
39 (task_size - kTransformTaskOverhead) / kMinTransformTaskSize;
40
41 const int real_tasks = std::max(1, std::min(max_threads, max_tasks_by_size));
42
43 if (real_tasks == 1) {
44 return false;
45 }
46
47 const int chunk = params.kernel.count / real_tasks;
48 for (int i = 0; i < real_tasks - 1; ++i) {
49 task_params->push_back(params);
50 Params& task = task_params->back();
51 task.kernel.count = chunk;
52 task.input = Util::OffsetInput(params.kernel, params.input, i * chunk);
53 task.output = Util::OffsetOutput(params.kernel, params.output, i * chunk);
54 }
55 task_params->push_back(params);
56 Params& task = task_params->back();
57 const int sum_chunk = (real_tasks - 1) * chunk;
58 task.kernel.count = params.kernel.count - sum_chunk;
59 task.input = Util::OffsetInput(params.kernel, params.input, sum_chunk);
60 task.output = Util::OffsetOutput(params.kernel, params.output, sum_chunk);
61 return true;
62}
63
64template <typename Params, int kernel_size>
65struct Transform1DTaskRunner : gemmlowp::Task {
66 Transform1DTaskRunner(const Params& params) : params(params) {}
67
68 void Run() override { Transform1D<Params, kernel_size>(params); }
69
70 Params params;
71};
72
73} // namespace internal
74
75template <typename MultiThreadingContext, typename Params, int kernel_size>
76inline void MultiThreadTransform1D(MultiThreadingContext* context,
77 const Params& params) {
78 typedef internal::Transform1DTaskRunner<Params, kernel_size> TaskRunnerType;
79
80 std::vector<Params> task_params;
81 if (!internal::PrepareTransform1DTasks<MultiThreadingContext, Params>(
82 context, params, kernel_size, &task_params)) {
83 Transform1D<Params, kernel_size>(params);
84 return;
85 }
86
87 auto workers_pool = context->workers_pool();
88 std::vector<Task*> tasks;
89 for (auto& task_param : task_params) {
90 tasks.push_back(new TaskRunnerType(task_param));
91 }
92 workers_pool->Execute(tasks);
93}
94
95} // namespace meta
96} // namespace gemmlowp
97
98#endif // GEMMLOWP_META_MULTI_THREAD_TRANSFORM_H_
99