Home
Browse Files
  1 /*
  2  *   Copyright (c) 2010, Michael Lehn
  3  *
  4  *   All rights reserved.
  5  *
  6  *   Redistribution and use in source and binary forms, with or without
  7  *   modification, are permitted provided that the following conditions
  8  *   are met:
  9  *
 10  *   1) Redistributions of source code must retain the above copyright
 11  *      notice, this list of conditions and the following disclaimer.
 12  *   2) Redistributions in binary form must reproduce the above copyright
 13  *      notice, this list of conditions and the following disclaimer in
 14  *      the documentation and/or other materials provided with the
 15  *      distribution.
 16  *   3) Neither the name of the FLENS development group nor the names of
 17  *      its contributors may be used to endorse or promote products derived
 18  *      from this software without specific prior written permission.
 19  *
 20  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 21  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 22  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 23  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 24  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 25  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 26  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 27  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 28  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 29  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 30  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 31  */
 32 
 33 
 34 #include <flens/blas/blaslogclear.h>
 35 
 36 #define FLENS_BLASLOG_SETTAG(tag)                                           \
 37     verbose::ClosureLog::setTag(tag)
 38 
 39 //------------------------------------------------------------------------------
 40 
 41 #define FLENS_BLASLOG_UNSETTAG                                              \
 42     verbose::ClosureLog::unsetTag()
 43 
 44 //------------------------------------------------------------------------------
 45 
 46 #define FLENS_BLASLOG_END                                                   \
 47     verbose::ClosureLog::closeEntry();
 48 
 49 //------------------------------------------------------------------------------
 50 
 51 #define FLENS_BLASLOG_BEGIN_ASSIGNMENT(X, Y)                                \
 52     if (verbose::ClosureLog::createEntry()) {                               \
 53         verbose::ClosureLog::separator();                                   \
 54         verbose::ClosureLog::append() << Y << " = " << X << ";";            \
 55         verbose::ClosureLog::append() << "flens::assign(" << X << ", " << Y \
 56                                       << ");";                              \
 57     }
 58 
 59 //------------------------------------------------------------------------------
 60 
 61 #define FLENS_BLASLOG_BEGIN_PLUSASSIGNMENT(X, Y)                            \
 62     if (verbose::ClosureLog::createEntry()) {                               \
 63         verbose::ClosureLog::separator();                                   \
 64         verbose::ClosureLog::append() << Y << " += " << X << ";";           \
 65         verbose::ClosureLog::append() << "flens::plusAssign("               \
 66                                       << X << ", " << Y << ");";            \
 67     }
 68 
 69 //------------------------------------------------------------------------------
 70 
 71 #define FLENS_BLASLOG_BEGIN_MINUSASSIGNMENT(X, Y)                           \
 72     if (verbose::ClosureLog::createEntry()) {                               \
 73         verbose::ClosureLog::separator();                                   \
 74         verbose::ClosureLog::append() << Y << " -= " << X << ";";           \
 75         verbose::ClosureLog::append() << "flens::minusAssign("              \
 76                                       << X << ", " << Y << ");";            \
 77     }
 78 
 79 //------------------------------------------------------------------------------
 80 
 81 #define FLENS_BLASLOG_IDENTICAL(A, B)                                       \
 82     if (verbose::ClosureLog::createEntry()) {                               \
 83         verbose::ClosureLog::append() << "Note that "                       \
 84                                       << A << " and " << B                  \
 85                                       << " are identical.";                 \
 86         verbose::ClosureLog::closeEntry();                                  \
 87     }
 88 
 89 //------------------------------------------------------------------------------
 90 
 91 #define FLENS_BLASLOG_TMP_ADD(tmp)                                          \
 92     if (verbose::ClosureLog::createEntry()) {                               \
 93         verbose::ClosureLog::variablePool.addTemporary(tmp);                \
 94         verbose::ClosureLog::closeEntry();                                  \
 95     }
 96 
 97 
 98 //------------------------------------------------------------------------------
 99 
100 #define FLENS_BLASLOG_TMP_TRON                                              \
101     verbose::ClosureLog::variablePool.tmpTron = true;                       \
102 
103 //------------------------------------------------------------------------------
104 
105 #define FLENS_BLASLOG_TMP_TROFF                                             \
106     verbose::ClosureLog::variablePool.tmpTron = false;                      \
107 
108 //------------------------------------------------------------------------------
109 
110 #define FLENS_BLASLOG_TMP_REMOVE(tmp, X)                                    \
111     if (verbose::ClosureLog::createEntry()) {                               \
112         verbose::ClosureLog::append() << "WARNING: Temporary " << tmp       \
113                                       << " was required for " << X;          \
114         verbose::ClosureLog::variablePool.removeTemporary(tmp);             \
115         verbose::ClosureLog::closeEntry();                                  \
116     }
117 
118 //------------------------------------------------------------------------------
119 
120 #define FLENS_BLASLOG_ERROR_COPY(X, Y)                                      \
121     if (verbose::ClosureLog::createEntry()) {                               \
122         verbose::ClosureLog::append() << "ERROR: Can not evaluate";         \
123         verbose::ClosureLog::append() << "flens::blas::copy("               \
124                                       << X << ", " << Y  << ");";           \
125         verbose::ClosureLog::append() << "Unknown operation in: " << X;     \
126         verbose::ClosureLog::stop();                                        \
127         ASSERT(0);                                                          \
128     }
129 
130 //------------------------------------------------------------------------------
131 
132 #define FLENS_BLASLOG_ERROR_MCOPY(TRANS, X, Y)                              \
133     if (verbose::ClosureLog::createEntry()) {                               \
134         verbose::ClosureLog::append() << "ERROR: Can not evaluate";         \
135         verbose::ClosureLog::append() << "flens::blas::copy(" << TRANS      \
136                                       << ", " << X << ", " << Y  << ");";   \
137         verbose::ClosureLog::append() << "Unknown operation in: " << X;     \
138         verbose::ClosureLog::stop();                                        \
139         ASSERT(0);                                                          \
140     }
141 
142 //------------------------------------------------------------------------------
143 
144 #define FLENS_BLASLOG_ERROR_AXPY(ALPHA, X, Y)                               \
145     if (verbose::ClosureLog::createEntry()) {                               \
146         verbose::ClosureLog::append() << "ERROR: Can not evaluate";         \
147         verbose::ClosureLog::append() << "flens::blas::axpy("               \
148                                       << ALPHA << ", " << X << ", " << Y    \
149                                       << ");";                              \
150         verbose::ClosureLog::append() << "Unknown operation in: " << X;     \
151         verbose::ClosureLog::stop();                                        \
152         ASSERT(0);                                                          \
153     }
154 
155 //------------------------------------------------------------------------------
156 
157 #define FLENS_BLASLOG_ERROR_MAXPY(TRANS, ALPHA, X, Y)                       \
158     if (verbose::ClosureLog::createEntry()) {                               \
159         verbose::ClosureLog::append() << "ERROR: Can not evaluate";         \
160         verbose::ClosureLog::append() << "flens::blas::axpy("               \
161                                       << TRANS << ","                       \
162                                       << ALPHA << ", " << X << ", " << Y    \
163                                       << ");";                              \
164         verbose::ClosureLog::append() << "Unknown operation in: " << X;     \
165         verbose::ClosureLog::stop();                                        \
166         ASSERT(0);                                                          \
167     }
168 
169 //------------------------------------------------------------------------------
170 
171 #define FLENS_BLASLOG_RESIZE_VECTOR(X, n)                                   \
172     if (verbose::ClosureLog::openEntry()) {                                 \
173         verbose::ClosureLog::append() << "WARNING: Resizing " << X          \
174                                       << " old dim = " << X.length()        \
175                                       << " new dim = " << n;                \
176     }
177 
178 //------------------------------------------------------------------------------
179 
180 #define FLENS_BLASLOG_RESIZE_MATRIX(A, m, n)                                \
181     if (verbose::ClosureLog::openEntry()) {                                 \
182         verbose::ClosureLog::append() << "WARNING: Resizing " << A          \
183                  << " old dim = " << A.numRows() << " x " << A.numCols()    \
184                  << ", new dim = " << m << " x " << n;                      \
185     }
186 
187 //------------------------------------------------------------------------------
188 
189 #define FLENS_BLASLOG_BEGIN_COPY(X, Y)                                      \
190     if (verbose::ClosureLog::createEntry()) {                               \
191         verbose::ClosureLog::append() << "flens::blas::copy("               \
192                                       << X << ", " << Y << ");";            \
193     }
194 
195 //------------------------------------------------------------------------------
196 
197 #define FLENS_BLASLOG_BEGIN_RESIDUAL(b, A, x, y)                            \
198     if (verbose::ClosureLog::createEntry()) {                               \
199         verbose::ClosureLog::append() << "residual("                        \
200             << b << ", " << A << ", " << x << ", " << y << ");";            \
201     }
202 
203 //------------------------------------------------------------------------------
204 
205 #define FLENS_BLASLOG_BEGIN_MCOPY(TRANS, X, Y)                              \
206     if (verbose::ClosureLog::createEntry()) {                               \
207         verbose::ClosureLog::append() << "flens::blas::copy(" << TRANS      \
208                                       << ", " << X << ", " << Y << ");";    \
209     }
210 
211 //------------------------------------------------------------------------------
212 
213 #define FLENS_BLASLOG_BEGIN_MCOTR(TRANS, X)                                 \
214     if (verbose::ClosureLog::createEntry()) {                               \
215         verbose::ClosureLog::append() << "flens::blas::cotr(" << TRANS      \
216                                       << ", " << X << ");";                 \
217     }
218 
219 //------------------------------------------------------------------------------
220 
221 #define FLENS_BLASLOG_BEGIN_AXPY(ALPHA, X, Y)                               \
222     if (verbose::ClosureLog::createEntry()) {                               \
223         verbose::ClosureLog::append() << "flens::blas::axpy("               \
224                                       << ALPHA << ", " << X << ", " << Y    \
225                                       << ");";                              \
226     }
227 
228 //------------------------------------------------------------------------------
229 
230 #define FLENS_BLASLOG_BEGIN_MAXPY(TRANS, ALPHA, X, Y)                       \
231     if (verbose::ClosureLog::createEntry()) {                               \
232         verbose::ClosureLog::append() << "flens::blas::axpy(" << TRANS      \
233                                       << ", " << ALPHA << ", " << X << ", " \
234                                       << Y  << ");";                        \
235     }
236 
237 //------------------------------------------------------------------------------
238 
239 #define FLENS_BLASLOG_BEGIN_RAXPY(ALPHA, X, Y)                              \
240     if (verbose::ClosureLog::createEntry()) {                               \
241         verbose::ClosureLog::append() << "flens::blas::raxpy("              \
242                                       << ALPHA << ", " << X << ", " << Y    \
243                                       << ");";                              \
244     }
245 
246 //------------------------------------------------------------------------------
247 
248 #define FLENS_BLASLOG_BEGIN_MRAXPY(TRANS, ALPHA, X, Y)                      \
249     if (verbose::ClosureLog::createEntry()) {                               \
250         verbose::ClosureLog::append() << "flens::blas::raxpy("              \
251                                       << TRANS << ", "                      \
252                                       << ALPHA << ", " << X << ", " << Y    \
253                                       << ");";                              \
254     }
255 
256 //------------------------------------------------------------------------------
257 
258 #define FLENS_BLASLOG_BEGIN_SCAL(ALPHA, X)                                  \
259     if (verbose::ClosureLog::createEntry()) {                               \
260         verbose::ClosureLog::append() << "flens::blas::scal("               \
261                                       << ALPHA << ", " << X << ");";        \
262     }
263 
264 //------------------------------------------------------------------------------
265 
266 #define FLENS_BLASLOG_BEGIN_RSCAL(ALPHA, X)                                 \
267     if (verbose::ClosureLog::createEntry()) {                               \
268         verbose::ClosureLog::append() << "flens::blas::rscal("              \
269                                       << ALPHA << ", " << X << ");";        \
270     }
271 
272 //------------------------------------------------------------------------------
273 
274 #define FLENS_BLASLOG_BEGIN_DOT(X, Y)                                       \
275     if (verbose::ClosureLog::createEntry()) {                               \
276         verbose::ClosureLog::separator();                                   \
277         verbose::ClosureLog::append() << "flens::blas::dot("                \
278                                       << X << ", " << Y << ");";            \
279     }
280 
281 //------------------------------------------------------------------------------
282 
283 #define FLENS_BLASLOG_BEGIN_GEMV(TRANS, ALPHA, A, X, BETA, Y)               \
284     if (verbose::ClosureLog::createEntry()) {                               \
285         verbose::ClosureLog::append() << "flens::blas::mv("                 \
286                                       << TRANS << ", " << ALPHA << ", "     \
287                                       << A << ", " << X << ", "             \
288                                       << BETA << ", "                       \
289                                       << Y << ");";                         \
290     }
291 
292 //------------------------------------------------------------------------------
293 
294 #define FLENS_BLASLOG_BEGIN_TRMV(TRANS, A, X)                               \
295     if (verbose::ClosureLog::createEntry()) {                               \
296         verbose::ClosureLog::append() << "flens::blas::mv("                 \
297                                       << TRANS << ", "                      \
298                                       << A << ", " << X                     \
299                                       << ");";                              \
300     }
301 
302 
303 //------------------------------------------------------------------------------
304 
305 #define FLENS_BLASLOG_BEGIN_GEMM(transA, transB, alpha, A, B, beta, C)      \
306     if (verbose::ClosureLog::createEntry()) {                               \
307         verbose::ClosureLog::append() << "flens::blas::mm("                 \
308                                       << transA << ", " << transB << ", "   \
309                                       << alpha << ", "                      \
310                                       << A << ", " << B << ", "             \
311                                       << beta << ", "                       \
312                                       << C << ");";                         \
313     }
314 
315 //------------------------------------------------------------------------------
316 
317 #define FLENS_BLASLOG_BEGIN_TRMM(side, transA, alpha, A, B)                 \
318     if (verbose::ClosureLog::createEntry()) {                               \
319         verbose::ClosureLog::append() << "flens::blas::mm("                 \
320                                       << side << ", " << transA << ", "     \
321                                       << alpha << ", "                      \
322                                       << A << ", " << B << ");";            \
323     }
324 
325 //------------------------------------------------------------------------------
326 
327 #define FLENS_BLASLOG_BEGIN_SYMM(side, alpha, A, B, beta, C)                \
328     if (verbose::ClosureLog::createEntry()) {                               \
329         verbose::ClosureLog::append() << "flens::blas::mm("                 \
330                                       << side << ", "                       \
331                                       << alpha << ", "                      \
332                                       << A << ", " << B << ", "             \
333                                       << beta << ", "                       \
334                                       << C << ");";                         \
335     }
336 
337 
338 
Home