Debian Codegraph @

src/acl/Kernels/aclKernelMerger.cxx

raw
1 /*
2 * Advanced Simulation Library <http://asl.org.il>
3 *
4 * Copyright 2015 Avtech Scientific <http://avtechscientific.com>
5 *
6 *
7 * This file is part of Advanced Simulation Library (ASL).
8 *
9 * ASL is free software: you can redistribute it and/or modify it
10 * under the terms of the GNU Affero General Public License as
11 * published by the Free Software Foundation, version 3 of the License.
12 *
13 * ASL is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Affero General Public License for more details.
17 *
18 * You should have received a copy of the GNU Affero General Public License
19 * along with ASL. If not, see <http://www.gnu.org/licenses/>.
20 *
21 */
22
23
24 #include "aclKernelMerger.h"
25 #include "aclKernel.h"
26 #include <acl/acl.h>
27 #include "acl/Operators/aclElementIfElse.h"
28 #include "acl/DataTypes/aclIndex.h"
29 #include "acl/DataTypes/aclConstant.h"
30 #include <aslUtilities.h>
31
32 namespace acl
33 {
34 KernelMerger::KernelMerger():
35 kernel(new Kernel())
36 {
37 }
38
39
40 void KernelMerger::compute()
41 {
42 kernel->compute();
43 }
44
45 unsigned int KernelMerger::getKernelSize(unsigned int i)
46 {
47 const KernelConfiguration &kc(kernels[i]->kernelConfig);
48 unsigned int size(kernels[i]->getSize());
49 if (kc.vectorWidth > 1)
50 {
51 size += (kc.vectorWidth - size % kc.vectorWidth) % kc.vectorWidth;
52 return size;
53 }
54 return size;
55 }
56
57
58 std::string KernelMerger::getKernelSource()
59 {
60 return kernel->getKernelSource();
61 }
62
63
64 void KernelMerger::clear()
65 {
66 kernels.clear();
67 offsets.clear();
68 kernel->clear();
69 }
70
71
72 void KernelMerger::addKernel(SPKernel k)
73 {
74 kernels.push_back(k);
75 }
76
77
78 void KernelMerger::addKernel(const KernelMerger & km)
79 {
80 for(unsigned int i(0); i < km.kernels.size(); ++i)
81 kernels.push_back(km.kernels[i]);
82 }
83
84
85 unsigned int KernelMerger::getSize()
86 {
87 return size;
88 }
89
90
91 void KernelMerger::computeOffsets()
92 {
93 size = getKernelSize(0);
94 offsets.resize(kernels.size() - 1);
95 for (unsigned int i(1); i < kernels.size(); ++i)
96 {
97 const KernelConfiguration &kc(kernels[0]->kernelConfig);
98 offsets[i-1] = kc.unaligned ? size : size / kc.vectorWidth;
99 size += getKernelSize(i);
100 }
101 }
102
103
104 void KernelMerger::setup()
105 {
106 if (!kernels.size())
107 asl::errorMessage("KernelMerger::setup() : no kernels have been added.");
108 if (kernels.size() > 1)
109 {
110 kernel.reset(new Kernel(kernels[0]->kernelConfig));
111 computeOffsets();
112 kernel->addExpression(castSpliter(0, kernels.size() - 1));
113 }
114 else
115 kernel = kernels[0];
116 kernel->setup();
117 }
118
119
120 void addToIfBody(std::shared_ptr<ElementIfElse> ife,
121 std::shared_ptr<Kernel> k,
122 unsigned int size)
123 {
124 Element ind(new Index(size));
125 for (unsigned int i(0); i < k->expression.size(); ++i)
126 ife->addBodyExpressionIf(elementOperators::excerpt(k->expression[i], ind));
127 }
128
129
130 void addToElseBody(std::shared_ptr<ElementIfElse> ife,
131 std::shared_ptr<Kernel> k,
132 unsigned int size)
133 {
134 Element ind(new Index(size));
135 for (unsigned int i(0); i < k->expression.size(); ++i)
136 ife->addBodyExpressionElse(elementOperators::excerpt(k->expression[i],ind));
137
138 }
139
140
141 Element KernelMerger::castSpliter(unsigned int i1, unsigned int i2)
142 {
143 Element ind(new Index(size));
144 if (i2 - i1 == 1)
145 {
146 using namespace elementOperators;
147 Element c(new Constant<int>(offsets[i1]));
148 shared_ptr<ElementIfElse> ife(new ElementIfElse(ind < c));
149 if (i1 > 0)
150 {
151 Element c(new Constant<int>(offsets[i1 - 1]));
152 ife->addBodyExpressionIf(ind -= c);
153 }
154 addToIfBody(ife, kernels[i1], size);
155 ife->addBodyExpressionElse(ind -= c);
156 addToElseBody(ife, kernels[i2], size);
157 return ife;
158 }
159 if (i2 - i1 == 2)
160 {
161 using namespace elementOperators;
162 Element c(new Constant<int>(offsets[i1]));
163 shared_ptr<ElementIfElse> ife(new ElementIfElse(ind < c));
164 if (i1 > 0)
165 {
166 Element c(new Constant<int>(offsets[i1 - 1]));
167 ife->addBodyExpressionIf(ind -= c);
168 }
169 addToIfBody(ife, kernels[i1],size);
170 ife->addBodyExpressionElse(castSpliter(i1 + 1, i2));
171 return ife;
172 }
173
174 using namespace elementOperators;
175 unsigned int midi(i1 + (i2 - i1) / 2);
176 Element c(new Constant<int>(offsets[midi]));
177 shared_ptr<ElementIfElse> ife(new ElementIfElse(ind < c));
178 ife->addBodyExpressionIf(castSpliter(i1, midi));
179 ife->addBodyExpressionElse(castSpliter(midi + 1, i2));
180
181 return ife;
182 }
183
184 } // namespace acl