diff options
118 files changed, 12971 insertions, 3 deletions
diff --git a/btl/COPYING b/btl/COPYING new file mode 100644 index 0000000..486449c --- /dev/null +++ b/btl/COPYING @@ -0,0 +1,340 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + <one line to give the program's name and a brief idea of what it does.> + Copyright (C) <year> <name of author> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + <signature of Ty Coon>, 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License. diff --git a/btl/README b/btl/README new file mode 100644 index 0000000..90db5b4 --- /dev/null +++ b/btl/README @@ -0,0 +1,3 @@ +This project contains a modified copy of the Bench Template Library. It has +been adapted in order to fit the needs of the project in which it has been used +and is in a "work in progress" state.
\ No newline at end of file diff --git a/btl/accuracy/lapack/diff.hh b/btl/accuracy/lapack/diff.hh new file mode 100644 index 0000000..6679655 --- /dev/null +++ b/btl/accuracy/lapack/diff.hh @@ -0,0 +1,47 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef DIFF_HH +#define DIFF_HH + +#include <vector> + +double diff(const int& N, const double* x, const double* test) +{ + std::vector<double> d(x, x+N); + const int iONE = 1; + const double alpha = -1.; + daxpy_(&N, &alpha, test, &iONE, &d[0], &iONE); + return dnrm2_(&N, &d[0], &iONE)/dnrm2_(&N, x, &iONE); +} + +template<typename T> +T diff(const std::vector<T> x, const std::vector<T> test) +{ + return diff(static_cast<const int&>(x.size()), &x[0], &test[0]); +} + +//float diff(const int& N, const float* x, const float* test) +//{ +// std::vector<float> d(x, x+N); +// const int iONE = 1; +// const float alpha = -1.; +// saxpy_(&N, &alpha, test, &iONE, &d[0], &iONE); +// return snrm2_(&N, &d[0], &iONE)/snrm2_(&N, x, &iONE); +//} + +#endif /* DIFF_HH */ diff --git a/btl/accuracy/lapack/lapack_LU.hh b/btl/accuracy/lapack/lapack_LU.hh new file mode 100644 index 0000000..686a97f --- /dev/null +++ b/btl/accuracy/lapack/lapack_LU.hh @@ -0,0 +1,74 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef LAPACK_LU_HH +#define LAPACK_LU_HH + +#include "LinearCongruential.hh" +#include "diff.hh" + +vector<int> get_piv(const vector<int>& ipiv) +{ + const int size = ipiv.size(); + vector<int> ret(size); + for (int i = 0; i < size; ++i) + ret[i] = i; + + int ii, jj, tmp; + for (int i = 1; i <= size; ++i) { + ii = i-1; + jj = ipiv[ii]-1; + tmp = ret[ii]; + ret[ii] = ret[jj]; + ret[jj] = tmp; + } + + return ret; +} + +double test_LU(const int& N, const unsigned& seed = 0) +{ + LinearCongruential lc(seed); + + vector<double> A(N*N), Acopy, P(N*N); + + /* Fill A and Acopy */ + for (int i = 0; i < N*N; ++i) + A[i] = lc.get_01(); + Acopy = A; + + /* Compute decomposition */ + vector<int> ipiv(N); + int info; + dgetrf_(&N, &N, &A[0], &N, &ipiv[0], &info); + vector<int> piv = get_piv(ipiv); + + /* Construct P */ + for (int r = 0; r < N; ++r) { + int c = piv[r]; + P[c+N*r] = 1; + } + + /* Test */ + const double alpha = 1.; + dtrmm_("R", "L", "N", "U", &N, &N, &alpha, &A[0], &N, &P[0], &N); + dtrmm_("R", "U", "N", "N", &N, &N, &alpha, &A[0], &N, &P[0], &N); + + return diff(Acopy, P); +} + +#endif /* LAPACK_LU_HH */ diff --git a/btl/accuracy/lapack/lapack_QR.hh b/btl/accuracy/lapack/lapack_QR.hh new file mode 100644 index 0000000..8b9ba82 --- /dev/null +++ b/btl/accuracy/lapack/lapack_QR.hh @@ -0,0 +1,74 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef LAPACK_QR_HH +#define LAPACK_QR_HH + +#include "LinearCongruential.hh" +#include "diff.hh" + +double test_QR(const int& N, const unsigned& seed = 0) +{ + LinearCongruential lc(seed); + vector<double> A(N*N), Acopy, tau(N), work(1), Q(N*N), H(N*N), tmp; + + /* Fill A and Acopy */ + for (int i = 0; i < N*N; ++i) + A[i] = lc.get_01(); + Acopy = A; + + /* Retrieve lwork */ + int lwork = -1, info; + dgeqrf_(&N, &N, &A[0], &N, &tau[0], &work[0], &lwork, &info); + lwork = work[0]; + work.resize(lwork); + + /* Compute decomposition */ + dgeqrf_(&N, &N, &A[0], &N, &tau[0], &work[0], &lwork, &info); + + /* Compute Q */ + for (int i = 0; i < N; ++i) + Q[i+i*N] = 1.; + + double alpha, t; + const double dZERO = 0., dONE = 1.; + const int iONE = 1, N2 = N*N; + work.resize(N2); + for (int i = 0; i < N; ++i) { + /* Generate H_i */ + for (int r = 0; r < N; ++r) + for (int c = r; c < N; ++c) + H[r+c*N] = (r == c); + dcopy_(&N, &A[i*N], &iONE, &work[0], &iONE); + for (int j = 0; j < i; ++j) + work[j] = 0.; + work[i] = 1.; + t = -tau[i]; + dsyr_("U", &N, &t, &work[0], &iONE, &H[0], &N); + + /* Multiply Q = Q*H_i */ + dsymm_("R", "U", &N, &N, &dONE, &H[0], &N, &Q[0], &N, &dZERO, &work[0], &N); + dcopy_(&N2, &work[0], &iONE, &Q[0], &iONE); + } + + /* Multiply */ + dtrmm_("R", "U", "N", "N", &N, &N, &dONE, &A[0], &N, &Q[0], &N); + + return diff(Acopy, Q); +} + +#endif /* LAPACK_QR_HH */ diff --git a/btl/accuracy/lapack/lapack_STEV.hh b/btl/accuracy/lapack/lapack_STEV.hh new file mode 100644 index 0000000..3fc9147 --- /dev/null +++ b/btl/accuracy/lapack/lapack_STEV.hh @@ -0,0 +1,52 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef LAPACK_STEV_HH +#define LAPACK_STEV_HH + +#include "LinearCongruential.hh" +#include "diff.hh" + +double test_STEV(const int& N, const unsigned& seed = 0) +{ + LinearCongruential lc(seed); + vector<double> A(N*N), D(N), E(N-1), Z(N*N), DD(N*N), work(max(1, 2*N-2)), tmp(N*N); + + /* Fill D, E and A */ + for (int i = 0; i < N-1; ++i) { + D[i] = lc.get_01(); A[i+i*N] = D[i]; + E[i] = lc.get_01(); A[(i+1)+i*N] = E[i]; A[i+(i+1)*N] = E[i]; + } + D[N-1] = lc.get_01(); A[N*N-1] = D[N-1]; + + /* Perform computation */ + int info; + dstev_("V", &N, &D[0], &E[0], &Z[0], &N, &work[0], &info); + + /* Construct DD */ + for (int i = 0; i < N; ++i) + DD[i+i*N] = D[i]; + + /* A = V*D*V' */ + const double dONE = 1., dZERO = 0.; + dgemm_("N", "N", &N, &N, &N, &dONE, &Z[0], &N, &DD[0], &N, &dZERO, &tmp[0], &N); + dgemm_("N", "T", &N, &N, &N, &dONE, &tmp[0], &N, &Z[0], &N, &dZERO, &DD[0], &N); + + return diff(A, DD); +} + +#endif /* LAPACK_STEV_HH */ diff --git a/btl/accuracy/lapack/lapack_SVD.hh b/btl/accuracy/lapack/lapack_SVD.hh new file mode 100644 index 0000000..7dc2ab1 --- /dev/null +++ b/btl/accuracy/lapack/lapack_SVD.hh @@ -0,0 +1,57 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef LAPACK_SVD_HH +#define LAPACK_SVD_HH + +#include "LinearCongruential.hh" +#include "diff.hh" + +double test_SVD(const int& N, const unsigned& seed = 0) +{ + LinearCongruential lc(seed); + + vector<double> A(N*N), Acopy, U(N*N), VT(N*N), S_(N), S(N*N); + vector<double> work(1); + + /* Fill A and Acopy */ + for (int i = 0; i < N*N; ++i) + A[i] = lc.get_01(); + Acopy = A; + + /* Retrieve lwork */ + int lwork = -1, info; + dgesvd_("A", "A", &N, &N, &A[0], &N, &S_[0], &U[0], &N, &VT[0], &N, &work[0], &lwork, &info); + lwork = work[0]; + work.resize(lwork); + + /* Compute decomposition */ + dgesvd_("A", "A", &N, &N, &A[0], &N, &S_[0], &U[0], &N, &VT[0], &N, &work[0], &lwork, &info); + + /* Construct S */ + for (int r = 0; r < N; ++r) + S[r+r*N] = S_[r]; + + /* Test */ + const double dONE = 1., dZERO = 0.; + dgemm_("N", "N", &N, &N, &N, &dONE, &U[0], &N, &S[0], &N, &dZERO, &A[0], &N); + dgemm_("N", "N", &N, &N, &N, &dONE, &A[0], &N, &VT[0], &N, &dZERO, &S[0], &N); + + return diff(Acopy, S); +} + +#endif /* LAPACK_SVD_HH */ diff --git a/btl/accuracy/lapack/lapack_SYEV.hh b/btl/accuracy/lapack/lapack_SYEV.hh new file mode 100644 index 0000000..dc6b733 --- /dev/null +++ b/btl/accuracy/lapack/lapack_SYEV.hh @@ -0,0 +1,60 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef LAPACK_SYEV_HH +#define LAPACK_SYEV_HH + +#include "LinearCongruential.hh" +#include "diff.hh" + +double test_SYEV(const int& N, const unsigned& seed = 0) +{ + LinearCongruential lc(seed); + vector<double> A(N*N), Acopy, W(N), D(N*N), work(1), tmp(N*N); + + /* Fill A (symmetric) and Acopy */ + for (int r = 0; r < N; ++r) { + A[r+r*N] = lc.get_01(); + for (int c = r+1; c < N; ++c) { + A[r+c*N] = lc.get_01(); + A[c+r*N] = A[r+c*N]; + } + } + Acopy = A; + + /* Retrieve lwork */ + int lwork = -1, info; + dsyev_("V", "U", &N, &A[0], &N, &W[0], &work[0], &lwork, &info); + lwork = work[0]; + work.resize(lwork); + + /* Perform computation */ + dsyev_("V", "U", &N, &A[0], &N, &W[0], &work[0], &lwork, &info); + + /* Construct D */ + for (int i = 0; i < N; ++i) + D[i+i*N] = W[i]; + + /* A = V*D*V' */ + const double dONE = 1., dZERO = 0.; + dgemm_("N", "N", &N, &N, &N, &dONE, &A[0], &N, &D[0], &N, &dZERO, &tmp[0], &N); + dgemm_("N", "T", &N, &N, &N, &dONE, &tmp[0], &N, &A[0], &N, &dZERO, &D[0], &N); + + return diff(Acopy, D); +} + +#endif /* LAPACK_SYEV_HH */ diff --git a/btl/accuracy/lapack/lapack_cholesky.hh b/btl/accuracy/lapack/lapack_cholesky.hh new file mode 100644 index 0000000..c398c0a --- /dev/null +++ b/btl/accuracy/lapack/lapack_cholesky.hh @@ -0,0 +1,54 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef LAPACK_CHOLESKY_HH +#define LAPACK_CHOLESKY_HH + +#include "LinearCongruential.hh" +#include "diff.hh" + +double test_cholesky(const int& N, const unsigned& seed = 0) +{ + LinearCongruential lc(seed); + + vector<double> A(N*N), Acopy, test(N*N); + + /* Fill A (SPD), Acopy and test (identity) */ + for (int r = 0; r < N; ++r) { + A[r+r*N] = N; + test[r+r*N] = 1.; + for (int c = r; c < N; ++c) { + A[r+c*N] += lc.get_01(); + A[c+r*N] = A[r+c*N]; + } + } + Acopy = A; + + /* Compute decomposition */ + int info; + dpotrf_("L", &N, &A[0], &N, &info); + + /* Test */ + const double alpha = 1.; + dtrmm_("L", "L", "N", "N", &N, &N, &alpha, &A[0], &N, &test[0], &N); + dtrmm_("R", "L", "T", "N", &N, &N, &alpha, &A[0], &N, &test[0], &N); + + return diff(Acopy, test); + +} + +#endif /* LAPACK_CHOLESKY_HH */ diff --git a/btl/accuracy/lapack/main_lapack.cpp b/btl/accuracy/lapack/main_lapack.cpp new file mode 100644 index 0000000..bd5db21 --- /dev/null +++ b/btl/accuracy/lapack/main_lapack.cpp @@ -0,0 +1,120 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#include "lapack.hh" +#include "LinearCongruential.hh" +#include "timer.hh" +#include "sizes.hh" + +#include <iostream> +#include <iomanip> +#include <vector> +#include <fstream> +#include <sstream> +#include <string> + +using namespace std; + +extern "C" { + void daxpy_(const int*, const double*, const double*, const int*, double*, const int*); + void dcopy_(const int*, const double*, const int*, double*, const int*); + double dnrm2_(const int*, const double*, const int*); + void dsyr_(const char*, const int*, const double*, const double*, const int*, double*, const int*); + void dger_(const int*, const int*, const double*, const double*, const int*, const double*, const int*, double*, const int*); + void dgemm_(const char*, const char*, const int*, const int*, const int*, const double*, const double*, const int*, const double*, const int*, const double*, double*, const int*); + void dsymm_(const char*, const char*, const int*, const int*, const double*, const double*, const int*, const double*, const int*, const double*, double*, const int*); + void dtrmm_(const char*, const char*, const char*, const char*, const int*, const int*, const double*, const double*, const int*, double*, const int*); +} +#include "lapack_LU.hh" +#include "lapack_cholesky.hh" +#include "lapack_SVD.hh" +#include "lapack_QR.hh" +#include "lapack_SYEV.hh" +#include "lapack_STEV.hh" + +template<typename exec_t> +void test(exec_t exec, const std::string& testname, const int& max = 3000, const int& N = 100) +{ + vector<int> sizes = logsizes(1, max, N); + Timer timer; + + ostringstream fname; + fname << "accuracy_" << testname << "_lapack.dat"; + cout << "Testing " << testname << " --> " << fname.str() << endl; + ofstream fs(fname.str().c_str()); + + for (vector<int>::const_iterator i = sizes.begin(), end = sizes.end(); i != end; ++i) { + const int size = *i; + double error = 0; + timer.start(); + int times = 0; + do + error += exec(size, times++); + while (timer.elapsed() < 1. || times < 16); + cout << " size: " << setw(4) << right << size; + cout << setw(15) << right << error/times << " "; + cout << "[" << setw(6) << times << " samples] "; + cout << "(" << setw(3) << right << (i-sizes.begin()+1) << "/" << N << ")" << endl; + fs << size << " " << error/times << "\n"; + } + + fs.close(); +} + +int main(int argc, char **argv) +{ + bool + lu_decomp=false, cholesky = false, svd_decomp=false, qr_decomp=false, + syev=false, stev=false + ; + + for (int i = 1; i < argc; ++i) { + std::string arg = argv[i]; + if (arg == "lu_decomp") lu_decomp = true; + else if (arg == "cholesky") cholesky = true; + else if (arg == "svd_decomp") svd_decomp = true; + else if (arg == "qr_decomp") qr_decomp = true; + else if (arg == "syev") syev = true; + else if (arg == "stev") stev = true; + } + + if (lu_decomp) { + test(test_LU, "lu_decomp", 3000, 100); + } + + if (cholesky) { + test(test_cholesky, "cholesky", 3000, 100); + } + + if (svd_decomp) { + test(test_SVD, "svd_decomp", 1000, 90); + } + + if (qr_decomp) { + test(test_QR, "qr_decomp", 500, 70); + } + + if (syev) { + test(test_SYEV, "syev", 1000, 90); + } + + if (stev) { + test(test_STEV, "stev", 1000, 90); + } + + return 0; +} diff --git a/btl/accuracy/lapack/timer.hh b/btl/accuracy/lapack/timer.hh new file mode 100644 index 0000000..82a0767 --- /dev/null +++ b/btl/accuracy/lapack/timer.hh @@ -0,0 +1,67 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef TIMER_HH +#define TIMER_HH + +#include <sys/time.h> + +class Timer +{ +public: + Timer() : ZERO(0.) + { } + + void start() + { + t = walltime(&ZERO); + } + + double elapsed() + { + return walltime(&t); + } + +private: + double t; + + const double ZERO; + + static double walltime(const double *t0) + { + double mic; + double time; + double mega = 0.000001; + struct timeval tp; + struct timezone tzp; + static long base_sec = 0; + static long base_usec = 0; + + (void) gettimeofday(&tp, &tzp); + if (base_sec == 0) { + base_sec = tp.tv_sec; + base_usec = tp.tv_usec; + } + + time = (double) (tp.tv_sec - base_sec); + mic = (double) (tp.tv_usec - base_usec); + time = (time + mic * mega) - *t0; + return (time); + } +}; + +#endif /* TIMER_HH */ diff --git a/btl/accuracy/main_blas.cpp b/btl/accuracy/main_blas.cpp new file mode 100644 index 0000000..aceae58 --- /dev/null +++ b/btl/accuracy/main_blas.cpp @@ -0,0 +1,253 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#include <iostream> +#include <fstream> +#include <sstream> +#include <string> +#include <vector> +#include <cmath> +#include <cstdlib> + +#define ADD_ +extern "C" { + void daxpy_(const int*, const double*, const double*, const int*, double*, const int*); + void dgemv_(const char*, const int*, const int*, const double*, const double*, const int*, const double*, const int*, const double*, double*, const int*); + void dtrsv_(const char*, const char*, const char*, const int*, const double*, const int*, double*, const int*); + void dgemm_(const char*, const char*, const int*, const int*, const int*, const double*, const double*, const int*, const double*, const int*, const double*, double*, const int*); + double dnrm2_(const int*, const double*, const int*); +} + +using namespace std; + +template<typename T> +void print_array(const int& N, const T* array) { + for (const T *p = array, *e = array+N; p != e; ++p) + cout << *p << " "; +} + +template<typename T> +void print_matrix(const int& rows, const int& cols, const T* matrix) { + for (int row = 0; row < rows; ++row) { + for (int col = 0; col < cols; ++col) + cout << *(matrix + rows*col + row) << " "; + cout << "\n"; + } +} + +template<typename T> +vector<T> logspace(const T& min, const T& max, const unsigned& N) +{ + vector<T> result; + result.reserve(N); + + const double emin = log(static_cast<double>(min)), emax = log(static_cast<double>(max)); + double e, r = (emax-emin)/(N-1); + for (unsigned i = 0; i < N; ++i) { + e = emin + i*r; + result.push_back(static_cast<T>(exp(e))); + } + + return result; +} + +template<typename T> +vector<T> logsizes(const T& min, const T& max, const unsigned& N) +{ + if (N <= 10) + return logspace(min, max, N); + + vector<T> result; + result.reserve(N); + + for (unsigned i = 0; i < 9; ++i) + result.push_back(i+1); + vector<T> lres = logspace(10, max, N-9); + for (unsigned i = 9; i < N; ++i) + result.push_back(lres[i-9]); + + return result; +} + +double axpy_test(const int& size) +{ + // Set up + const int ONE = 1; + const double alpha = 1./3.; + double *x = new double[size], *y = new double[size]; + for (int i = 1; i <= size; ++i) { + x[i-1] = 10. / i; + y[i-1] = -10./(3. * i); + } + + // Execute + daxpy_(&size, &alpha, x, &ONE, y, &ONE); + + // Compute the error + double error = dnrm2_(&size, y, &ONE); + + delete[] x; delete[] y; + return error; +} + +double matrix_vector_test(const int& size) +{ + // Set up + const int ONE = 1; + char TRANS = 'N'; + const double alpha = 1./size, beta = 1.; + double *A = new double[size*size], *x = new double[size], *y = new double[size]; + for (int i = 1; i <= size; ++i) { + x[i-1] = i; + y[i-1] = -i; + for (int j = 1; j <= size; ++j) { + *(A+i-1+(j-1)*size) = static_cast<double>(i)/j; + } + } + + // Execute + dgemv_(&TRANS, &size, &size, &alpha, A, &size, x, &ONE, &beta, y, &ONE); + + // Compute the error + double error = dnrm2_(&size, y, &ONE); + + delete[] A; delete[] x; delete[] y; + return error; +} + +double trisolve_vector_test(const int& size) +{ + // Set up + const int ONE = 1; + char UPLO = 'U', TRANS = 'N', DIAG = 'U'; + double *A = new double[size*size], *x = new double[size+1], *y = new double[size]; + const double alpha = 1.; + x[size] = 0.; + for (int i = 1; i <= size; ++i) { + x[size-i] = x[size-i+1] + 1./i; + y[i-1] = -1.; + for (int j = i; j <= size; ++j) { + *(A+i-1+(j-1)*size) = 1. / (j-i+1); + } + } + + // Execute + dtrsv_(&UPLO, &TRANS, &DIAG, &size, A, &size, x, &ONE); + daxpy_(&size, &alpha, x, &ONE, y, &ONE); + double error = dnrm2_(&size, y, &ONE); + + delete[] A; delete[] x; delete[] y; + return error; +} + +double matrix_matrix_test(const int& size) +{ + // rand48 initialization + srand48(5); + + // sigma = SUM[k=1..size](k) + double sigma = 0; + for (int i = 1; i <= size; ++i) + sigma += i; + + // Set up + const int ONE = 1; + char TRANS = 'N'; + const double alpha = drand48(), beta = -2. * alpha * sigma; + const int size2 = size*size; + double *A = new double[size2], *B = new double[size2], *C = new double[size2]; + + for (int i = 1; i <= size; ++i) + for (int j = 1; j <= size; ++j) { + *(A+i-1+size*(j-1)) = static_cast<double>(j)/i; + *(B+i-1+size*(j-1)) = j; + *(C+i-1+size*(j-1)) = static_cast<double>(j)/(2.*i); + } + + // Execute + dgemm_(&TRANS, &TRANS, &size, &size, &size, &alpha, A, &size, B, &size, &beta, C, &size); + double error = dnrm2_(&size2, C, &ONE); + + delete[] A; delete[] B; delete[] C; + return error; +} + +template<typename T> +void test(T t, const int& min, const int& max, const unsigned& N, const string& name) +{ + ostringstream fname; + ofstream fout; + double result; + int N_; + + fname << "accuracy_" << name << "_blas.dat"; + fout.open(fname.str().c_str()); + cout << name << " test -- " << fname.str() << endl; + vector<int> axpy_sizes = logsizes(min, max, N); + N_ = 0; + for (vector<int>::const_reverse_iterator i = axpy_sizes.rbegin(), e = axpy_sizes.rend(); i!=e; ++i) { + result = t(*i); + fout << *i << " " << result << endl; + cout << " size: " << *i << " " << result << " (" << ++N_ << "/100)" << endl; + } + fout.close(); + cout << "\n"; +} + +int main(int argv, char **argc) +{ + bool + axpy=false, axpby=false, rot=false, + matrix_vector=false, atv=false, symv=false, syr2=false, ger=false, trisolve_vector=false, + matrix_matrix=false, aat=false, trisolve_matrix=false, trmm=false + ; + + + for (int i = 1; i < argv; ++i) { + std::string arg = argc[i]; + if (arg == "axpy") axpy = true; + else if (arg == "axpby") axpby = true; + else if (arg == "rot") rot = true; + else if (arg == "matrix_vector") matrix_vector = true; + else if (arg == "atv") atv = true; + else if (arg == "symv") symv = true; + else if (arg == "syr2") syr2 = true; + else if (arg == "ger") ger = true; + else if (arg == "trisolve_vector") trisolve_vector = true; + else if (arg == "matrix_matrix") matrix_matrix = true; + else if (arg == "aat") aat = true; + else if (arg == "trisolve_matrix") trisolve_matrix = true; + else if (arg == "trmm") trmm = true; + } + + + /* AXPY test */ + if (axpy) + test(axpy_test, 1, 1000000, 100, "axpy"); + + if (matrix_vector) + test(matrix_vector_test, 1, 3000, 100, "matrix_vector"); + + if (trisolve_vector) + test(trisolve_vector_test, 1, 3000, 100, "trisolve_vector"); + + if (matrix_matrix) + test(matrix_matrix_test, 1, 2000, 100, "matrix_matrix"); + + return 0; + +} diff --git a/btl/accuracy/sizes.hh b/btl/accuracy/sizes.hh new file mode 100644 index 0000000..be458bf --- /dev/null +++ b/btl/accuracy/sizes.hh @@ -0,0 +1,59 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef SIZES_HH +#define SIZES_HH + +#include <vector> +#include <cmath> + +template<typename T> +std::vector<T> logspace(const T& min, const T& max, const unsigned& N) +{ + std::vector<T> result; + result.reserve(N); + + const double emin = std::log(static_cast<double>(min)), + emax = std::log(static_cast<double>(max)); + double e, r = (emax-emin)/(N-1); + for (unsigned i = 0; i < N; ++i) { + e = emin + i*r; + result.push_back(static_cast<T>(exp(e))); + } + + return result; +} + +template<typename T> +std::vector<T> logsizes(const T& min, const T& max, const unsigned& N) +{ + if (N <= 10) + return logspace(min, max, N); + + std::vector<T> result; + result.reserve(N); + + for (unsigned i = 0; i < 9; ++i) + result.push_back(i+1); + std::vector<T> lres = logspace(10, max, N-9); + for (unsigned i = 9; i < N; ++i) + result.push_back(lres[i-9]); + + return result; +} + +#endif /* SIZES_HH */ diff --git a/btl/actions/action_aat_product.hh b/btl/actions/action_aat_product.hh new file mode 100644 index 0000000..aa5b35c --- /dev/null +++ b/btl/actions/action_aat_product.hh @@ -0,0 +1,145 @@ +//===================================================== +// File : action_aat_product.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, lun sep 30 14:23:19 CEST 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_AAT_PRODUCT +#define ACTION_AAT_PRODUCT +#include "utilities.h" +#include "STL_interface.hh" +#include <string> +#include "init/init_function.hh" +#include "init/init_vector.hh" +#include "init/init_matrix.hh" + +using namespace std; + +template<class Interface> +class Action_aat_product { + +public : + + // Ctor + + Action_aat_product( int size ):_size(size) + { + MESSAGE("Action_aat_product Ctor"); + + // STL matrix and vector initialization + + init_matrix<pseudo_random>(A_stl,_size); + init_matrix<null_function>(X_stl,_size); + init_matrix<null_function>(resu_stl,_size); + + // generic matrix and vector initialization + + Interface::matrix_from_stl(A_ref,A_stl); + Interface::matrix_from_stl(X_ref,X_stl); + + Interface::matrix_from_stl(A,A_stl); + Interface::matrix_from_stl(X,X_stl); + + } + + // invalidate copy ctor + + Action_aat_product( const Action_aat_product & ) + { + INFOS("illegal call to Action_aat_product Copy Ctor"); + exit(0); + } + + // Dtor + + ~Action_aat_product( void ){ + + MESSAGE("Action_aat_product Dtor"); + + // deallocation + + Interface::free_matrix(A,_size); + Interface::free_matrix(X,_size); + + Interface::free_matrix(A_ref,_size); + Interface::free_matrix(X_ref,_size); + + } + + // action name + + static inline std::string name( void ) + { + return "aat_"+Interface::name(); + } + + double nb_op_base( void ){ + return double(_size)*double(_size)*double(_size); + } + + inline void initialize( void ){ + + Interface::copy_matrix(A_ref,A,_size); + Interface::copy_matrix(X_ref,X,_size); + + } + + inline void calculate( void ) { + + Interface::aat_product(A,X,_size); + + } + + void check_result( void ){ + if (_size>128) return; + // calculation check + + Interface::matrix_to_stl(X,resu_stl); + + STL_interface<typename Interface::real_type>::aat_product(A_stl,X_stl,_size); + + typename Interface::real_type error= + STL_interface<typename Interface::real_type>::norm_diff(X_stl,resu_stl); + + if (error>1.e-6){ + INFOS("WRONG CALCULATION...residual=" << error); + exit(1); + } + + } + +private : + + typename Interface::stl_matrix A_stl; + typename Interface::stl_matrix X_stl; + typename Interface::stl_matrix resu_stl; + + typename Interface::gene_matrix A_ref; + typename Interface::gene_matrix X_ref; + + typename Interface::gene_matrix A; + typename Interface::gene_matrix X; + + + int _size; + +}; + + +#endif + + + diff --git a/btl/actions/action_ata_product.hh b/btl/actions/action_ata_product.hh new file mode 100644 index 0000000..04364fe --- /dev/null +++ b/btl/actions/action_ata_product.hh @@ -0,0 +1,145 @@ +//===================================================== +// File : action_ata_product.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, lun sep 30 14:23:19 CEST 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_ATA_PRODUCT +#define ACTION_ATA_PRODUCT +#include "utilities.h" +#include "STL_interface.hh" +#include <string> +#include "init/init_function.hh" +#include "init/init_vector.hh" +#include "init/init_matrix.hh" + +using namespace std; + +template<class Interface> +class Action_ata_product { + +public : + + // Ctor + + Action_ata_product( int size ):_size(size) + { + MESSAGE("Action_ata_product Ctor"); + + // STL matrix and vector initialization + + init_matrix<pseudo_random>(A_stl,_size); + init_matrix<null_function>(X_stl,_size); + init_matrix<null_function>(resu_stl,_size); + + // generic matrix and vector initialization + + Interface::matrix_from_stl(A_ref,A_stl); + Interface::matrix_from_stl(X_ref,X_stl); + + Interface::matrix_from_stl(A,A_stl); + Interface::matrix_from_stl(X,X_stl); + + } + + // invalidate copy ctor + + Action_ata_product( const Action_ata_product & ) + { + INFOS("illegal call to Action_ata_product Copy Ctor"); + exit(0); + } + + // Dtor + + ~Action_ata_product( void ){ + + MESSAGE("Action_ata_product Dtor"); + + // deallocation + + Interface::free_matrix(A,_size); + Interface::free_matrix(X,_size); + + Interface::free_matrix(A_ref,_size); + Interface::free_matrix(X_ref,_size); + + } + + // action name + + static inline std::string name( void ) + { + return "ata_"+Interface::name(); + } + + double nb_op_base( void ){ + return 2.0*_size*_size*_size; + } + + inline void initialize( void ){ + + Interface::copy_matrix(A_ref,A,_size); + Interface::copy_matrix(X_ref,X,_size); + + } + + inline void calculate( void ) { + + Interface::ata_product(A,X,_size); + + } + + void check_result( void ){ + if (_size>128) return; + // calculation check + + Interface::matrix_to_stl(X,resu_stl); + + STL_interface<typename Interface::real_type>::ata_product(A_stl,X_stl,_size); + + typename Interface::real_type error= + STL_interface<typename Interface::real_type>::norm_diff(X_stl,resu_stl); + + if (error>1.e-6){ + INFOS("WRONG CALCULATION...residual=" << error); + exit(1); + } + + } + +private : + + typename Interface::stl_matrix A_stl; + typename Interface::stl_matrix X_stl; + typename Interface::stl_matrix resu_stl; + + typename Interface::gene_matrix A_ref; + typename Interface::gene_matrix X_ref; + + typename Interface::gene_matrix A; + typename Interface::gene_matrix X; + + + int _size; + +}; + + +#endif + + + diff --git a/btl/actions/action_atv_product.hh b/btl/actions/action_atv_product.hh new file mode 100644 index 0000000..a823451 --- /dev/null +++ b/btl/actions/action_atv_product.hh @@ -0,0 +1,134 @@ +//===================================================== +// File : action_atv_product.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, lun sep 30 14:23:19 CEST 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_ATV_PRODUCT +#define ACTION_ATV_PRODUCT +#include "utilities.h" +#include "STL_interface.hh" +#include <string> +#include "init/init_function.hh" +#include "init/init_vector.hh" +#include "init/init_matrix.hh" + +using namespace std; + +template<class Interface> +class Action_atv_product { + +public : + + Action_atv_product( int size ) : _size(size) + { + MESSAGE("Action_atv_product Ctor"); + + // STL matrix and vector initialization + + init_matrix<pseudo_random>(A_stl,_size); + init_vector<pseudo_random>(B_stl,_size); + init_vector<null_function>(X_stl,_size); + init_vector<null_function>(resu_stl,_size); + + // generic matrix and vector initialization + + Interface::matrix_from_stl(A_ref,A_stl); + Interface::vector_from_stl(B_ref,B_stl); + Interface::vector_from_stl(X_ref,X_stl); + + Interface::matrix_from_stl(A,A_stl); + Interface::vector_from_stl(B,B_stl); + Interface::vector_from_stl(X,X_stl); + } + + // invalidate copy ctor + Action_atv_product( const Action_atv_product & ) + { + INFOS("illegal call to Action_atv_product Copy Ctor"); + exit(1); + } + + ~Action_atv_product( void ) + { + MESSAGE("Action_atv_product Dtor"); + + Interface::free_matrix(A,_size); + Interface::free_vector(B); + Interface::free_vector(X); + + Interface::free_matrix(A_ref,_size); + Interface::free_vector(B_ref); + Interface::free_vector(X_ref); + } + + static inline std::string name() { return "atv_" + Interface::name(); } + + double nb_op_base( void ) { return 2.0*_size*_size; } + + inline void initialize( void ){ + Interface::copy_matrix(A_ref,A,_size); + Interface::copy_vector(B_ref,B,_size); + Interface::copy_vector(X_ref,X,_size); + } + + BTL_DONT_INLINE void calculate( void ) { + BTL_ASM_COMMENT("begin atv"); + Interface::atv_product(A,B,X,_size); + BTL_ASM_COMMENT("end atv"); + } + + void check_result( void ) + { + if (_size>128) return; + Interface::vector_to_stl(X,resu_stl); + + STL_interface<typename Interface::real_type>::atv_product(A_stl,B_stl,X_stl,_size); + + typename Interface::real_type error= + STL_interface<typename Interface::real_type>::norm_diff(X_stl,resu_stl); + + if (error>1.e-6){ + INFOS("WRONG CALCULATION...residual=" << error); + exit(1); + } + } + +private : + + typename Interface::stl_matrix A_stl; + typename Interface::stl_vector B_stl; + typename Interface::stl_vector X_stl; + typename Interface::stl_vector resu_stl; + + typename Interface::gene_matrix A_ref; + typename Interface::gene_vector B_ref; + typename Interface::gene_vector X_ref; + + typename Interface::gene_matrix A; + typename Interface::gene_vector B; + typename Interface::gene_vector X; + + + int _size; + +}; + + +#endif + + + diff --git a/btl/actions/action_axpby.hh b/btl/actions/action_axpby.hh new file mode 100644 index 0000000..98511ab --- /dev/null +++ b/btl/actions/action_axpby.hh @@ -0,0 +1,127 @@ +//===================================================== +// File : action_axpby.hh +// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_AXPBY +#define ACTION_AXPBY +#include "utilities.h" +#include "STL_interface.hh" +#include <string> +#include "init/init_function.hh" +#include "init/init_vector.hh" +#include "init/init_matrix.hh" + +using namespace std; + +template<class Interface> +class Action_axpby { + +public : + + // Ctor + Action_axpby( int size ):_size(size),_alpha(0.5),_beta(0.95) + { + MESSAGE("Action_axpby Ctor"); + + // STL vector initialization + init_vector<pseudo_random>(X_stl,_size); + init_vector<pseudo_random>(Y_stl,_size); + init_vector<null_function>(resu_stl,_size); + + // generic matrix and vector initialization + Interface::vector_from_stl(X_ref,X_stl); + Interface::vector_from_stl(Y_ref,Y_stl); + + Interface::vector_from_stl(X,X_stl); + Interface::vector_from_stl(Y,Y_stl); + } + + // invalidate copy ctor + Action_axpby( const Action_axpby & ) + { + INFOS("illegal call to Action_axpby Copy Ctor"); + exit(1); + } + + // Dtor + ~Action_axpby( void ){ + MESSAGE("Action_axpby Dtor"); + + // deallocation + Interface::free_vector(X_ref); + Interface::free_vector(Y_ref); + + Interface::free_vector(X); + Interface::free_vector(Y); + } + + // action name + static inline std::string name( void ) + { + return "axpby_"+Interface::name(); + } + + double nb_op_base( void ){ + return 3.0*_size; + } + + inline void initialize( void ){ + Interface::copy_vector(X_ref,X,_size); + Interface::copy_vector(Y_ref,Y,_size); + } + + inline void calculate( void ) { + BTL_ASM_COMMENT("mybegin axpby"); + Interface::axpby(_alpha,X,_beta,Y,_size); + BTL_ASM_COMMENT("myend axpby"); + } + + void check_result( void ){ + if (_size>128) return; + // calculation check + Interface::vector_to_stl(Y,resu_stl); + + STL_interface<typename Interface::real_type>::axpby(_alpha,X_stl,_beta,Y_stl,_size); + + typename Interface::real_type error= + STL_interface<typename Interface::real_type>::norm_diff(Y_stl,resu_stl); + + if (error>1.e-6){ + INFOS("WRONG CALCULATION...residual=" << error); + exit(2); + } + } + +private : + + typename Interface::stl_vector X_stl; + typename Interface::stl_vector Y_stl; + typename Interface::stl_vector resu_stl; + + typename Interface::gene_vector X_ref; + typename Interface::gene_vector Y_ref; + + typename Interface::gene_vector X; + typename Interface::gene_vector Y; + + typename Interface::real_type _alpha; + typename Interface::real_type _beta; + + int _size; +}; + +#endif diff --git a/btl/actions/action_axpy.hh b/btl/actions/action_axpy.hh new file mode 100644 index 0000000..e4cb3a5 --- /dev/null +++ b/btl/actions/action_axpy.hh @@ -0,0 +1,139 @@ +//===================================================== +// File : action_axpy.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, lun sep 30 14:23:19 CEST 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_AXPY +#define ACTION_AXPY +#include "utilities.h" +#include "STL_interface.hh" +#include <string> +#include "init/init_function.hh" +#include "init/init_vector.hh" +#include "init/init_matrix.hh" + +using namespace std; + +template<class Interface> +class Action_axpy { + +public : + + // Ctor + + Action_axpy( int size ):_size(size),_coef(1.0) + { + MESSAGE("Action_axpy Ctor"); + + // STL vector initialization + + init_vector<pseudo_random>(X_stl,_size); + init_vector<pseudo_random>(Y_stl,_size); + init_vector<null_function>(resu_stl,_size); + + // generic matrix and vector initialization + + Interface::vector_from_stl(X_ref,X_stl); + Interface::vector_from_stl(Y_ref,Y_stl); + + Interface::vector_from_stl(X,X_stl); + Interface::vector_from_stl(Y,Y_stl); + + + } + + // invalidate copy ctor + + Action_axpy( const Action_axpy & ) + { + INFOS("illegal call to Action_axpy Copy Ctor"); + exit(1); + } + + // Dtor + + ~Action_axpy( void ){ + + MESSAGE("Action_axpy Dtor"); + + // deallocation + + Interface::free_vector(X_ref); + Interface::free_vector(Y_ref); + + Interface::free_vector(X); + Interface::free_vector(Y); + } + + // action name + + static inline std::string name( void ) + { + return "axpy_"+Interface::name(); + } + + double nb_op_base( void ){ + return 2.0*_size; + } + + inline void initialize( void ){ + Interface::copy_vector(X_ref,X,_size); + Interface::copy_vector(Y_ref,Y,_size); + } + + inline void calculate( void ) { + BTL_ASM_COMMENT("mybegin axpy"); + Interface::axpy(_coef,X,Y,_size); + BTL_ASM_COMMENT("myend axpy"); + } + + void check_result( void ){ + if (_size>128) return; + // calculation check + + Interface::vector_to_stl(Y,resu_stl); + + STL_interface<typename Interface::real_type>::axpy(_coef,X_stl,Y_stl,_size); + + typename Interface::real_type error= + STL_interface<typename Interface::real_type>::norm_diff(Y_stl,resu_stl); + + if (error>1.e-6){ + INFOS("WRONG CALCULATION...residual=" << error); + exit(0); + } + + } + +private : + + typename Interface::stl_vector X_stl; + typename Interface::stl_vector Y_stl; + typename Interface::stl_vector resu_stl; + + typename Interface::gene_vector X_ref; + typename Interface::gene_vector Y_ref; + + typename Interface::gene_vector X; + typename Interface::gene_vector Y; + + typename Interface::real_type _coef; + + int _size; +}; + +#endif diff --git a/btl/actions/action_cholesky.hh b/btl/actions/action_cholesky.hh new file mode 100644 index 0000000..a1c751b --- /dev/null +++ b/btl/actions/action_cholesky.hh @@ -0,0 +1,129 @@ +//===================================================== +// File : action_cholesky.hh +// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_CHOLESKY +#define ACTION_CHOLESKY +#include "utilities.h" +#include "STL_interface.hh" +#include <string> +#include <cmath> +#include "init/init_function.hh" +#include "init/init_vector.hh" +#include "init/init_matrix.hh" + +using namespace std; + +template<class Interface> +class Action_cholesky { + +public : + + // Ctor + + Action_cholesky( int size ):_size(size) + { + MESSAGE("Action_cholesky Ctor"); + + // STL mat/vec initialization + init_matrix_symm<pseudo_random>(X_stl,_size); + init_matrix<null_function>(C_stl,_size); + + // make sure X is invertible + for (int i=0; i<_size; ++i) + X_stl[i][i] = std::abs(X_stl[i][i]) * 1e2 + 100; + + // generic matrix and vector initialization + Interface::matrix_from_stl(X_ref,X_stl); + Interface::matrix_from_stl(X,X_stl); + Interface::matrix_from_stl(C,C_stl); + + _cost = 0; + for (int j=0; j<_size; ++j) + { + double r = std::max(_size - j -1,0); + _cost += 2*(r*j+r+j); + } + } + + // invalidate copy ctor + + Action_cholesky( const Action_cholesky & ) + { + INFOS("illegal call to Action_cholesky Copy Ctor"); + exit(1); + } + + // Dtor + + ~Action_cholesky( void ){ + + MESSAGE("Action_cholesky Dtor"); + + // deallocation + Interface::free_matrix(X_ref,_size); + Interface::free_matrix(X,_size); + Interface::free_matrix(C,_size); + } + + // action name + + static inline std::string name( void ) + { + return "cholesky_"+Interface::name(); + } + + double nb_op_base( void ){ + return _cost; + } + + inline void initialize( void ){ + Interface::copy_matrix(X_ref,X,_size); + } + + inline void calculate( void ) { + Interface::cholesky(X,C,_size); + } + + void check_result( void ){ + // calculation check +// STL_interface<typename Interface::real_type>::cholesky(X_stl,C_stl,_size); +// +// typename Interface::real_type error= +// STL_interface<typename Interface::real_type>::norm_diff(C_stl,resu_stl); +// +// if (error>1.e-6){ +// INFOS("WRONG CALCULATION...residual=" << error); +// exit(0); +// } + + } + +private : + + typename Interface::stl_matrix X_stl; + typename Interface::stl_matrix C_stl; + + typename Interface::gene_matrix X_ref; + typename Interface::gene_matrix X; + typename Interface::gene_matrix C; + + int _size; + double _cost; +}; + +#endif diff --git a/btl/actions/action_fftw_1d.hh b/btl/actions/action_fftw_1d.hh new file mode 100644 index 0000000..25424d6 --- /dev/null +++ b/btl/actions/action_fftw_1d.hh @@ -0,0 +1,128 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_FFTW_1D +#define ACTION_FFTW_1D +#include <string> +#include <cmath> + +#include "base_action_fftw.hh" + + +/* FORWARD - MEASURE */ +template<class Interface> +class Action_FFTW_1D_Forward_Measure : public Action_FFTW_base<Interface> +{ +public: + // Constructor + Action_FFTW_1D_Forward_Measure(const int& size) : + Action_FFTW_base<Interface>(size, 1) + { + Interface::fftw_init_plan(this->p, size, this->X, this->Y, FFTW_FORWARD, FFTW_MEASURE); + } + + // Action name + static inline std::string name( void ) + { + return "FFTW_1D_Forward_Measure_"+Interface::name(); + } + + // Algorithm complexity + double nb_op_base( void ){ + const static double log_2 = std::log(2.); + return this->size_ * std::log(this->size_)/log_2; + } +}; + + +/* FORWARD - ESTIMATE */ +template<class Interface> +class Action_FFTW_1D_Forward_Estimate : public Action_FFTW_base<Interface> +{ +public: + // Constructor + Action_FFTW_1D_Forward_Estimate(const int& size) : + Action_FFTW_base<Interface>(size, 1) + { + Interface::fftw_init_plan(this->p, size, this->X, this->Y, FFTW_FORWARD, FFTW_ESTIMATE); + } + + // Action name + static inline std::string name( void ) + { + return "FFTW_1D_Forward_Estimate_"+Interface::name(); + } + + // Algorithm complexity + double nb_op_base( void ){ + const static double log_2 = std::log(2.); + return this->size_ * std::log(this->size_)/log_2; + } +}; + +/* BACKWARD - MEASURE */ +template<class Interface> +class Action_FFTW_1D_Backward_Measure : public Action_FFTW_base<Interface> +{ +public: + // Constructor + Action_FFTW_1D_Backward_Measure(const int& size) : + Action_FFTW_base<Interface>(size, 1) + { + Interface::fftw_init_plan(this->p, size, this->X, this->Y, FFTW_BACKWARD, FFTW_MEASURE); + } + + // Action name + static inline std::string name( void ) + { + return "FFTW_1D_Backward_Measure_"+Interface::name(); + } + + // Algorithm complexity + double nb_op_base( void ){ + const static double log_2 = std::log(2.); + return this->size_ * std::log(this->size_)/log_2; + } +}; + + +/* BACKWARD - ESTIMATE */ +template<class Interface> +class Action_FFTW_1D_Backward_Estimate : public Action_FFTW_base<Interface> +{ +public: + // Constructor + Action_FFTW_1D_Backward_Estimate(const int& size) : + Action_FFTW_base<Interface>(size, 1) + { + Interface::fftw_init_plan(this->p, size, this->X, this->Y, FFTW_BACKWARD, FFTW_ESTIMATE); + } + + // Action name + static inline std::string name( void ) + { + return "FFTW_1D_Backward_Estimate_"+Interface::name(); + } + + // Algorithm complexity + double nb_op_base( void ){ + const static double log_2 = std::log(2.); + return this->size_ * std::log(this->size_)/log_2; + } +}; + +#endif // ACTION_FFTW_1D diff --git a/btl/actions/action_fftw_2d.hh b/btl/actions/action_fftw_2d.hh new file mode 100644 index 0000000..34b13e1 --- /dev/null +++ b/btl/actions/action_fftw_2d.hh @@ -0,0 +1,128 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_FFTW_2D +#define ACTION_FFTW_2D +#include <string> +#include <cmath> + +#include "base_action_fftw.hh" + + +/* FORWARD - MEASURE */ +template<class Interface> +class Action_FFTW_2D_Forward_Measure : public Action_FFTW_base<Interface> +{ +public: + // Constructor + Action_FFTW_2D_Forward_Measure(const int& size) : + Action_FFTW_base<Interface>(size, 2) + { + Interface::fftw_init_plan_2d(this->p, size, this->X, this->Y, FFTW_FORWARD, FFTW_MEASURE); + } + + // Action name + static inline std::string name( void ) + { + return "FFTW_2D_Forward_Measure_"+Interface::name(); + } + + // Algorithm complexity + double nb_op_base( void ){ + const static double log_2 = std::log(2.); + return (this->size_ * std::log(this->size_)/log_2) * 2*this->size_; + } +}; + + +/* FORWARD - ESTIMATE */ +template<class Interface> +class Action_FFTW_2D_Forward_Estimate : public Action_FFTW_base<Interface> +{ +public: + // Constructor + Action_FFTW_2D_Forward_Estimate(const int& size) : + Action_FFTW_base<Interface>(size, 2) + { + Interface::fftw_init_plan_2d(this->p, size, this->X, this->Y, FFTW_FORWARD, FFTW_ESTIMATE); + } + + // Action name + static inline std::string name( void ) + { + return "FFTW_2D_Forward_Estimate_"+Interface::name(); + } + + // Algorithm complexity + double nb_op_base( void ){ + const static double log_2 = std::log(2.); + return (this->size_ * std::log(this->size_)/log_2) * 2*this->size_; + } +}; + +/* BACKWARD - MEASURE */ +template<class Interface> +class Action_FFTW_2D_Backward_Measure : public Action_FFTW_base<Interface> +{ +public: + // Constructor + Action_FFTW_2D_Backward_Measure(const int& size) : + Action_FFTW_base<Interface>(size, 2) + { + Interface::fftw_init_plan_2d(this->p, size, this->X, this->Y, FFTW_BACKWARD, FFTW_MEASURE); + } + + // Action name + static inline std::string name( void ) + { + return "FFTW_2D_Backward_Measure_"+Interface::name(); + } + + // Algorithm complexity + double nb_op_base( void ){ + const static double log_2 = std::log(2.); + return (this->size_ * std::log(this->size_)/log_2) * 2*this->size_; + } +}; + + +/* BACKWARD - ESTIMATE */ +template<class Interface> +class Action_FFTW_2D_Backward_Estimate : public Action_FFTW_base<Interface> +{ +public: + // Constructor + Action_FFTW_2D_Backward_Estimate(const int& size) : + Action_FFTW_base<Interface>(size, 2) + { + Interface::fftw_init_plan_2d(this->p, size, this->X, this->Y, FFTW_BACKWARD, FFTW_ESTIMATE); + } + + // Action name + static inline std::string name( void ) + { + return "FFTW_2D_Backward_Estimate_"+Interface::name(); + } + + // Algorithm complexity + double nb_op_base( void ){ + const static double log_2 = std::log(2.); + return (this->size_ * std::log(this->size_)/log_2) * 2*this->size_; + } +}; + +#endif // ACTION_FFTW_2D diff --git a/btl/actions/action_fftw_3d.hh b/btl/actions/action_fftw_3d.hh new file mode 100644 index 0000000..a9714db --- /dev/null +++ b/btl/actions/action_fftw_3d.hh @@ -0,0 +1,129 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_FFTW_3D +#define ACTION_FFTW_3D +#include <string> +#include <cmath> + +#include "base_action_fftw.hh" + + +/* FORWARD - MEASURE */ +template<class Interface> +class Action_FFTW_3D_Forward_Measure : public Action_FFTW_base<Interface> +{ +public: + // Constructor + Action_FFTW_3D_Forward_Measure(const int& size) : + Action_FFTW_base<Interface>(size, 3) + { + Interface::fftw_init_plan_3d(this->p, size, this->X, this->Y, FFTW_FORWARD, FFTW_MEASURE); + } + + // Action name + static inline std::string name( void ) + { + return "FFTW_3D_Forward_Measure_"+Interface::name(); + } + + // Algorithm complexity + double nb_op_base( void ){ + const static double log_2 = std::log(2.); + return (this->size_ * std::log(this->size_)/log_2) * 3*this->size_*this->size_; + } +}; + + +/* FORWARD - ESTIMATE */ +template<class Interface> +class Action_FFTW_3D_Forward_Estimate : public Action_FFTW_base<Interface> +{ +public: + // Constructor + Action_FFTW_3D_Forward_Estimate(const int& size) : + Action_FFTW_base<Interface>(size, 3) + { + Interface::fftw_init_plan_3d(this->p, size, this->X, this->Y, FFTW_FORWARD, FFTW_ESTIMATE); + } + + // Action name + static inline std::string name( void ) + { + return "FFTW_3D_Forward_Estimate_"+Interface::name(); + } + + // Algorithm complexity + double nb_op_base( void ){ + const static double log_2 = std::log(2.); + return (this->size_ * std::log(this->size_)/log_2) * 3*this->size_*this->size_; + } +}; + +/* BACKWARD - MEASURE */ +template<class Interface> +class Action_FFTW_3D_Backward_Measure : public Action_FFTW_base<Interface> +{ +public: + // Constructor + Action_FFTW_3D_Backward_Measure(const int& size) : + Action_FFTW_base<Interface>(size, 3) + { + Interface::fftw_init_plan_3d(this->p, size, this->X, this->Y, FFTW_BACKWARD, FFTW_MEASURE); + } + + // Action name + static inline std::string name( void ) + { + return "FFTW_3D_Backward_Measure_"+Interface::name(); + } + + // Algorithm complexity + double nb_op_base( void ){ + const static double log_2 = std::log(2.); + return (this->size_ * std::log(this->size_)/log_2) * 3*this->size_*this->size_; + } +}; + + +/* BACKWARD - ESTIMATE */ +template<class Interface> +class Action_FFTW_3D_Backward_Estimate : public Action_FFTW_base<Interface> +{ +public: + // Constructor + Action_FFTW_3D_Backward_Estimate(const int& size) : + Action_FFTW_base<Interface>(size, 3) + { + Interface::fftw_init_plan_3d(this->p, size, this->X, this->Y, FFTW_BACKWARD, FFTW_ESTIMATE); + } + + // Action name + static inline std::string name( void ) + { + return "FFTW_3D_Backward_Estimate_"+Interface::name(); + } + + // Algorithm complexity + double nb_op_base( void ){ + const static double log_2 = std::log(2.); + return (this->size_ * std::log(this->size_)/log_2) * 3*this->size_*this->size_; + } +}; + +#endif // ACTION_FFTW_3D + diff --git a/btl/actions/action_general_solve.hh b/btl/actions/action_general_solve.hh new file mode 100644 index 0000000..78aebd8 --- /dev/null +++ b/btl/actions/action_general_solve.hh @@ -0,0 +1,137 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_GENERAL_SOLVE +#define ACTION_GENERAL_SOLVE + +#include "utilities.h" +#include "STL_interface.hh" +#include <string> +#include "init/init_function.hh" +#include "init/init_vector.hh" +#include "init/init_matrix.hh" + +using namespace std; + +template<class Interface> +class Action_general_solve { + +public: + + // Ctor + Action_general_solve( int size ) : _size(size) + { + MESSAGE("Action_general_solve Ctor"); + + // STL matrix and vector initialization + + init_matrix<pseudo_random>(A_stl,_size); + init_vector<pseudo_random>(B_stl,_size); + init_vector<null_function>(X_stl,_size); + init_vector<null_function>(resu_stl,_size); + + // generic matrix and vector initialization + + Interface::matrix_from_stl(A_ref,A_stl); + Interface::matrix_from_stl(A,A_stl); + Interface::vector_from_stl(B_ref,B_stl); + Interface::vector_from_stl(B,B_stl); + Interface::vector_from_stl(X_ref,X_stl); + Interface::vector_from_stl(X,X_stl); + + + } + + // invalidate copy ctor + + Action_general_solve( const Action_general_solve & ) + { + INFOS("illegal call to Action_general_solve Copy Ctor"); + exit(0); + } + + // Dtor + + BTL_DONT_INLINE ~Action_general_solve( void ){ + + MESSAGE("Action_general_solve Dtor"); + + // deallocation + + Interface::free_matrix(A,_size); + Interface::free_vector(B); + Interface::free_vector(X); + + Interface::free_matrix(A_ref,_size); + Interface::free_vector(B_ref); + Interface::free_vector(X_ref); + + } + + // action name + + static inline std::string name( void ) + { + return "general_solve_" + Interface::name(); + } + + double nb_op_base( void ){ + return 2.0*_size*_size*_size; + } + + BTL_DONT_INLINE void initialize( void ){ + + Interface::copy_matrix(A_ref,A,_size); + Interface::copy_vector(B_ref,B,_size); + Interface::copy_vector(X_ref,X,_size); + + } + + BTL_DONT_INLINE void calculate( void ) { + BTL_ASM_COMMENT("#begin general_solve"); + Interface::general_solve(A,B,X,_size); + BTL_ASM_COMMENT("end general_solve"); + } + + BTL_DONT_INLINE void check_result() { + // TODO: check result + } + + +private: + + typename Interface::stl_matrix A_stl; + typename Interface::stl_vector B_stl; + typename Interface::stl_vector X_stl; + typename Interface::stl_vector resu_stl; + + typename Interface::gene_matrix A_ref; + typename Interface::gene_vector B_ref; + typename Interface::gene_vector X_ref; + + typename Interface::gene_matrix A; + typename Interface::gene_vector B; + typename Interface::gene_vector X; + + + int _size; + + +}; + + +#endif// ACTION_GENERAL_SOLVE diff --git a/btl/actions/action_ger.hh b/btl/actions/action_ger.hh new file mode 100644 index 0000000..dc766ef --- /dev/null +++ b/btl/actions/action_ger.hh @@ -0,0 +1,128 @@ + +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_GER +#define ACTION_GER +#include "utilities.h" +#include "STL_interface.hh" +#include <string> +#include "init/init_function.hh" +#include "init/init_vector.hh" +#include "init/init_matrix.hh" + +using namespace std; + +template<class Interface> +class Action_ger { + +public : + + // Ctor + BTL_DONT_INLINE Action_ger( int size ):_size(size) + { + MESSAGE("Action_ger Ctor"); + + // STL matrix and vector initialization + typename Interface::stl_matrix tmp; + init_matrix<pseudo_random>(A_stl,_size); + init_vector<pseudo_random>(B_stl,_size); + init_vector<pseudo_random>(X_stl,_size); + init_vector<null_function>(resu_stl,_size); + + // generic matrix and vector initialization + Interface::matrix_from_stl(A_ref,A_stl); + Interface::matrix_from_stl(A,A_stl); + Interface::vector_from_stl(B_ref,B_stl); + Interface::vector_from_stl(B,B_stl); + Interface::vector_from_stl(X_ref,X_stl); + Interface::vector_from_stl(X,X_stl); + } + + // invalidate copy ctor + Action_ger( const Action_ger & ) + { + INFOS("illegal call to Action_ger Copy Ctor"); + exit(1); + } + + // Dtor + BTL_DONT_INLINE ~Action_ger( void ){ + MESSAGE("Action_ger Dtor"); + Interface::free_matrix(A,_size); + Interface::free_vector(B); + Interface::free_vector(X); + Interface::free_matrix(A_ref,_size); + Interface::free_vector(B_ref); + Interface::free_vector(X_ref); + + } + + // action name + static inline std::string name( void ) + { + return "ger_" + Interface::name(); + } + + double nb_op_base( void ){ + return 2.0*_size*_size; + } + + BTL_DONT_INLINE void initialize( void ){ + Interface::copy_matrix(A_ref,A,_size); + Interface::copy_vector(B_ref,B,_size); + Interface::copy_vector(X_ref,X,_size); + } + + BTL_DONT_INLINE void calculate( void ) { + BTL_ASM_COMMENT("#begin ger"); + Interface::ger(A,B,X,_size); + BTL_ASM_COMMENT("end ger"); + } + + BTL_DONT_INLINE void check_result( void ){ + // calculation check + Interface::vector_to_stl(X,resu_stl); + + STL_interface<typename Interface::real_type>::ger(A_stl,B_stl,X_stl,_size); + + typename Interface::real_type error= + STL_interface<typename Interface::real_type>::norm_diff(X_stl,resu_stl); + + if (error>1.e-3){ + INFOS("WRONG CALCULATION...residual=" << error); +// exit(0); + } + + } + +private : + + typename Interface::stl_matrix A_stl; + typename Interface::stl_vector B_stl; + typename Interface::stl_vector X_stl; + typename Interface::stl_vector resu_stl; + + typename Interface::gene_matrix A_ref; + typename Interface::gene_vector B_ref; + typename Interface::gene_vector X_ref; + + typename Interface::gene_matrix A; + typename Interface::gene_vector B; + typename Interface::gene_vector X; + + int _size; +}; + + +#endif diff --git a/btl/actions/action_hessenberg.hh b/btl/actions/action_hessenberg.hh new file mode 100644 index 0000000..2100ebd --- /dev/null +++ b/btl/actions/action_hessenberg.hh @@ -0,0 +1,233 @@ +//===================================================== +// File : action_hessenberg.hh +// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_HESSENBERG +#define ACTION_HESSENBERG +#include "utilities.h" +#include "STL_interface.hh" +#include <string> +#include "init/init_function.hh" +#include "init/init_vector.hh" +#include "init/init_matrix.hh" + +using namespace std; + +template<class Interface> +class Action_hessenberg { + +public : + + // Ctor + + Action_hessenberg( int size ):_size(size) + { + MESSAGE("Action_hessenberg Ctor"); + + // STL vector initialization + init_matrix<pseudo_random>(X_stl,_size); + + init_matrix<null_function>(C_stl,_size); + init_matrix<null_function>(resu_stl,_size); + + // generic matrix and vector initialization + Interface::matrix_from_stl(X_ref,X_stl); + Interface::matrix_from_stl(X,X_stl); + Interface::matrix_from_stl(C,C_stl); + + _cost = 0; + for (int j=0; j<_size-2; ++j) + { + double r = std::max(0,_size-j-1); + double b = std::max(0,_size-j-2); + _cost += 6 + 3*b + r*r*4 + r*_size*4; + } + } + + // invalidate copy ctor + + Action_hessenberg( const Action_hessenberg & ) + { + INFOS("illegal call to Action_hessenberg Copy Ctor"); + exit(1); + } + + // Dtor + + ~Action_hessenberg( void ){ + + MESSAGE("Action_hessenberg Dtor"); + + // deallocation + Interface::free_matrix(X_ref,_size); + Interface::free_matrix(X,_size); + Interface::free_matrix(C,_size); + } + + // action name + + static inline std::string name( void ) + { + return "hessenberg_"+Interface::name(); + } + + double nb_op_base( void ){ + return _cost; + } + + inline void initialize( void ){ + Interface::copy_matrix(X_ref,X,_size); + } + + inline void calculate( void ) { + Interface::hessenberg(X,C,_size); + } + + void check_result( void ){ + // calculation check + Interface::matrix_to_stl(C,resu_stl); + +// STL_interface<typename Interface::real_type>::hessenberg(X_stl,C_stl,_size); +// +// typename Interface::real_type error= +// STL_interface<typename Interface::real_type>::norm_diff(C_stl,resu_stl); +// +// if (error>1.e-6){ +// INFOS("WRONG CALCULATION...residual=" << error); +// exit(0); +// } + + } + +private : + + typename Interface::stl_matrix X_stl; + typename Interface::stl_matrix C_stl; + typename Interface::stl_matrix resu_stl; + + typename Interface::gene_matrix X_ref; + typename Interface::gene_matrix X; + typename Interface::gene_matrix C; + + int _size; + double _cost; +}; + +template<class Interface> +class Action_tridiagonalization { + +public : + + // Ctor + + Action_tridiagonalization( int size ):_size(size) + { + MESSAGE("Action_tridiagonalization Ctor"); + + // STL vector initialization + init_matrix<pseudo_random>(X_stl,_size); + + for(int i=0; i<_size; ++i) + { + for(int j=0; j<i; ++j) + X_stl[i][j] = X_stl[j][i]; + } + + init_matrix<null_function>(C_stl,_size); + init_matrix<null_function>(resu_stl,_size); + + // generic matrix and vector initialization + Interface::matrix_from_stl(X_ref,X_stl); + Interface::matrix_from_stl(X,X_stl); + Interface::matrix_from_stl(C,C_stl); + + _cost = 0; + for (int j=0; j<_size-2; ++j) + { + double r = std::max(0,_size-j-1); + double b = std::max(0,_size-j-2); + _cost += 6. + 3.*b + r*r*8.; + } + } + + // invalidate copy ctor + + Action_tridiagonalization( const Action_tridiagonalization & ) + { + INFOS("illegal call to Action_tridiagonalization Copy Ctor"); + exit(1); + } + + // Dtor + + ~Action_tridiagonalization( void ){ + + MESSAGE("Action_tridiagonalization Dtor"); + + // deallocation + Interface::free_matrix(X_ref,_size); + Interface::free_matrix(X,_size); + Interface::free_matrix(C,_size); + } + + // action name + + static inline std::string name( void ) { return "tridiagonalization_"+Interface::name(); } + + double nb_op_base( void ){ + return _cost; + } + + inline void initialize( void ){ + Interface::copy_matrix(X_ref,X,_size); + } + + inline void calculate( void ) { + Interface::tridiagonalization(X,C,_size); + } + + void check_result( void ){ + // calculation check + Interface::matrix_to_stl(C,resu_stl); + +// STL_interface<typename Interface::real_type>::tridiagonalization(X_stl,C_stl,_size); +// +// typename Interface::real_type error= +// STL_interface<typename Interface::real_type>::norm_diff(C_stl,resu_stl); +// +// if (error>1.e-6){ +// INFOS("WRONG CALCULATION...residual=" << error); +// exit(0); +// } + + } + +private : + + typename Interface::stl_matrix X_stl; + typename Interface::stl_matrix C_stl; + typename Interface::stl_matrix resu_stl; + + typename Interface::gene_matrix X_ref; + typename Interface::gene_matrix X; + typename Interface::gene_matrix C; + + int _size; + double _cost; +}; + +#endif diff --git a/btl/actions/action_least_squares.hh b/btl/actions/action_least_squares.hh new file mode 100644 index 0000000..f13c7dc --- /dev/null +++ b/btl/actions/action_least_squares.hh @@ -0,0 +1,137 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_LEAST_SQUARES +#define ACTION_LEAST_SQUARES + +#include "utilities.h" +#include "STL_interface.hh" +#include <string> +#include "init/init_function.hh" +#include "init/init_vector.hh" +#include "init/init_matrix.hh" + +using namespace std; + +template<class Interface> +class Action_least_squares { + +public: + + // Ctor + Action_least_squares( int size ) : _size(size) + { + MESSAGE("Action_least_squares Ctor"); + + // STL matrix and vector initialization + + init_matrix<pseudo_random>(A_stl,_size); + init_vector<pseudo_random>(B_stl,_size); + init_vector<null_function>(X_stl,_size); + init_vector<null_function>(resu_stl,_size); + + // generic matrix and vector initialization + + Interface::matrix_from_stl(A_ref,A_stl); + Interface::matrix_from_stl(A,A_stl); + Interface::vector_from_stl(B_ref,B_stl); + Interface::vector_from_stl(B,B_stl); + Interface::vector_from_stl(X_ref,X_stl); + Interface::vector_from_stl(X,X_stl); + + + } + + // invalidate copy ctor + + Action_least_squares( const Action_least_squares & ) + { + INFOS("illegal call to Action_least_squares Copy Ctor"); + exit(0); + } + + // Dtor + + BTL_DONT_INLINE ~Action_least_squares( void ){ + + MESSAGE("Action_least_squares Dtor"); + + // deallocation + + Interface::free_matrix(A,_size); + Interface::free_vector(B); + Interface::free_vector(X); + + Interface::free_matrix(A_ref,_size); + Interface::free_vector(B_ref); + Interface::free_vector(X_ref); + + } + + // action name + + static inline std::string name( void ) + { + return "least_squares_" + Interface::name(); + } + + double nb_op_base( void ){ + return 2.0*_size*_size*_size; + } + + BTL_DONT_INLINE void initialize( void ){ + + Interface::copy_matrix(A_ref,A,_size); + Interface::copy_vector(B_ref,B,_size); + Interface::copy_vector(X_ref,X,_size); + + } + + BTL_DONT_INLINE void calculate( void ) { + BTL_ASM_COMMENT("#begin least_squares"); + Interface::least_squares(A,B,X,_size); + BTL_ASM_COMMENT("end least_squares"); + } + + BTL_DONT_INLINE void check_result() { + // TODO: check result + } + + +private: + + typename Interface::stl_matrix A_stl; + typename Interface::stl_vector B_stl; + typename Interface::stl_vector X_stl; + typename Interface::stl_vector resu_stl; + + typename Interface::gene_matrix A_ref; + typename Interface::gene_vector B_ref; + typename Interface::gene_vector X_ref; + + typename Interface::gene_matrix A; + typename Interface::gene_vector B; + typename Interface::gene_vector X; + + + int _size; + + +}; + + +#endif // ACTION_LEAST_SQUARES diff --git a/btl/actions/action_lu_decomp.hh b/btl/actions/action_lu_decomp.hh new file mode 100644 index 0000000..770c87d --- /dev/null +++ b/btl/actions/action_lu_decomp.hh @@ -0,0 +1,109 @@ +//===================================================== +// File : action_lu_decomp.hh +// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_LU_DECOMP +#define ACTION_LU_DECOMP +#include "utilities.h" +#include "STL_interface.hh" +#include <string> +#include "init/init_function.hh" +#include "init/init_vector.hh" +#include "init/init_matrix.hh" + +using namespace std; + +template<class Interface> +class Action_lu_decomp { + +public : + + // Ctor + + Action_lu_decomp( int size ):_size(size) + { + MESSAGE("Action_lu_decomp Ctor"); + + // STL vector initialization + init_matrix<pseudo_random>(X_stl,_size); + + init_matrix<null_function>(C_stl,_size); + + // generic matrix and vector initialization + Interface::matrix_from_stl(X_ref,X_stl); + Interface::matrix_from_stl(X,X_stl); + Interface::matrix_from_stl(C,C_stl); + + _cost = 2.0*size*size*size/3.0 + size*size; + } + + // invalidate copy ctor + + Action_lu_decomp( const Action_lu_decomp & ) + { + INFOS("illegal call to Action_lu_decomp Copy Ctor"); + exit(1); + } + + // Dtor + + ~Action_lu_decomp( void ){ + + MESSAGE("Action_lu_decomp Dtor"); + + // deallocation + Interface::free_matrix(X_ref,_size); + Interface::free_matrix(X,_size); + Interface::free_matrix(C,_size); + } + + // action name + + static inline std::string name( void ) + { + return "lu_decomp_"+Interface::name(); + } + + double nb_op_base( void ){ + return _cost; + } + + inline void initialize( void ){ + Interface::copy_matrix(X_ref,X,_size); + } + + inline void calculate( void ) { + Interface::lu_decomp(X,C,_size); + } + + void check_result( void ){ + } + +private : + + typename Interface::stl_matrix X_stl; + typename Interface::stl_matrix C_stl; + + typename Interface::gene_matrix X_ref; + typename Interface::gene_matrix X; + typename Interface::gene_matrix C; + + int _size; + double _cost; +}; + +#endif diff --git a/btl/actions/action_lu_solve.hh b/btl/actions/action_lu_solve.hh new file mode 100644 index 0000000..5a81e63 --- /dev/null +++ b/btl/actions/action_lu_solve.hh @@ -0,0 +1,136 @@ +//===================================================== +// File : action_lu_solve.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, lun sep 30 14:23:19 CEST 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_LU_SOLVE +#define ACTION_LU_SOLVE +#include "utilities.h" +#include "STL_interface.hh" +#include <string> +#include "init/init_function.hh" +#include "init/init_vector.hh" +#include "init/init_matrix.hh" + +using namespace std; + +template<class Interface> +class Action_lu_solve +{ + +public : + + static inline std::string name( void ) + { + return "lu_solve_"+Interface::name(); + } + + static double nb_op_base(int size){ + return 2.0*size*size*size/3.0; // questionable but not really important + } + + + static double calculate( int nb_calc, int size ) { + + // STL matrix and vector initialization + + typename Interface::stl_matrix A_stl; + typename Interface::stl_vector B_stl; + typename Interface::stl_vector X_stl; + + init_matrix<pseudo_random>(A_stl,size); + init_vector<pseudo_random>(B_stl,size); + init_vector<null_function>(X_stl,size); + + // generic matrix and vector initialization + + typename Interface::gene_matrix A; + typename Interface::gene_vector B; + typename Interface::gene_vector X; + + typename Interface::gene_matrix LU; + + Interface::matrix_from_stl(A,A_stl); + Interface::vector_from_stl(B,B_stl); + Interface::vector_from_stl(X,X_stl); + Interface::matrix_from_stl(LU,A_stl); + + // local variable : + + typename Interface::Pivot_Vector pivot; // pivot vector + Interface::new_Pivot_Vector(pivot,size); + + // timer utilities + + Portable_Timer chronos; + + // time measurement + + chronos.start(); + + for (int ii=0;ii<nb_calc;ii++){ + + // LU factorization + Interface::copy_matrix(A,LU,size); + Interface::LU_factor(LU,pivot,size); + + // LU solve + + Interface::LU_solve(LU,pivot,B,X,size); + + } + + // Time stop + + chronos.stop(); + + double time=chronos.user_time(); + + // check result : + + typename Interface::stl_vector B_new_stl(size); + Interface::vector_to_stl(X,X_stl); + + STL_interface<typename Interface::real_type>::matrix_vector_product(A_stl,X_stl,B_new_stl,size); + + typename Interface::real_type error= + STL_interface<typename Interface::real_type>::norm_diff(B_stl,B_new_stl); + + if (error>1.e-5){ + INFOS("WRONG CALCULATION...residual=" << error); + STL_interface<typename Interface::real_type>::display_vector(B_stl); + STL_interface<typename Interface::real_type>::display_vector(B_new_stl); + exit(0); + } + + // deallocation and return time + + Interface::free_matrix(A,size); + Interface::free_vector(B); + Interface::free_vector(X); + Interface::free_Pivot_Vector(pivot); + + return time; + } + +}; + + +#endif + + + diff --git a/btl/actions/action_matrix_matrix_product.hh b/btl/actions/action_matrix_matrix_product.hh new file mode 100644 index 0000000..f65ee05 --- /dev/null +++ b/btl/actions/action_matrix_matrix_product.hh @@ -0,0 +1,150 @@ +//===================================================== +// File : action_matrix_matrix_product.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, lun sep 30 14:23:19 CEST 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_MATRIX_MATRIX_PRODUCT +#define ACTION_MATRIX_MATRIX_PRODUCT +#include "utilities.h" +#include "STL_interface.hh" +#include <string> +#include "init/init_function.hh" +#include "init/init_vector.hh" +#include "init/init_matrix.hh" + +using namespace std; + +template<class Interface> +class Action_matrix_matrix_product { + +public : + + // Ctor + + Action_matrix_matrix_product( int size ):_size(size) + { + MESSAGE("Action_matrix_matrix_product Ctor"); + + // STL matrix and vector initialization + + init_matrix<pseudo_random>(A_stl,_size); + init_matrix<pseudo_random>(B_stl,_size); + init_matrix<null_function>(X_stl,_size); + init_matrix<null_function>(resu_stl,_size); + + // generic matrix and vector initialization + + Interface::matrix_from_stl(A_ref,A_stl); + Interface::matrix_from_stl(B_ref,B_stl); + Interface::matrix_from_stl(X_ref,X_stl); + + Interface::matrix_from_stl(A,A_stl); + Interface::matrix_from_stl(B,B_stl); + Interface::matrix_from_stl(X,X_stl); + + } + + // invalidate copy ctor + + Action_matrix_matrix_product( const Action_matrix_matrix_product & ) + { + INFOS("illegal call to Action_matrix_matrix_product Copy Ctor"); + exit(0); + } + + // Dtor + + ~Action_matrix_matrix_product( void ){ + + MESSAGE("Action_matrix_matrix_product Dtor"); + + // deallocation + + Interface::free_matrix(A,_size); + Interface::free_matrix(B,_size); + Interface::free_matrix(X,_size); + + Interface::free_matrix(A_ref,_size); + Interface::free_matrix(B_ref,_size); + Interface::free_matrix(X_ref,_size); + + } + + // action name + + static inline std::string name( void ) + { + return "matrix_matrix_"+Interface::name(); + } + + double nb_op_base( void ){ + return 2.0*_size*_size*_size; + } + + inline void initialize( void ){ + + Interface::copy_matrix(A_ref,A,_size); + Interface::copy_matrix(B_ref,B,_size); + Interface::copy_matrix(X_ref,X,_size); + + } + + inline void calculate( void ) { + Interface::matrix_matrix_product(A,B,X,_size); + } + + void check_result( void ){ + + // calculation check + if (_size<200) + { + Interface::matrix_to_stl(X,resu_stl); + STL_interface<typename Interface::real_type>::matrix_matrix_product(A_stl,B_stl,X_stl,_size); + typename Interface::real_type error= + STL_interface<typename Interface::real_type>::norm_diff(X_stl,resu_stl); + if (error>1.e-6){ + INFOS("WRONG CALCULATION...residual=" << error); + exit(1); + } + } + } + +private : + + typename Interface::stl_matrix A_stl; + typename Interface::stl_matrix B_stl; + typename Interface::stl_matrix X_stl; + typename Interface::stl_matrix resu_stl; + + typename Interface::gene_matrix A_ref; + typename Interface::gene_matrix B_ref; + typename Interface::gene_matrix X_ref; + + typename Interface::gene_matrix A; + typename Interface::gene_matrix B; + typename Interface::gene_matrix X; + + + int _size; + +}; + + +#endif + + + diff --git a/btl/actions/action_matrix_matrix_product_bis.hh b/btl/actions/action_matrix_matrix_product_bis.hh new file mode 100644 index 0000000..29c10a6 --- /dev/null +++ b/btl/actions/action_matrix_matrix_product_bis.hh @@ -0,0 +1,152 @@ +//===================================================== +// File : action_matrix_matrix_product_bis.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, lun sep 30 14:23:19 CEST 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_MATRIX_MATRIX_PRODUCT_BIS +#define ACTION_MATRIX_MATRIX_PRODUCT_BIS +#include "utilities.h" +#include "STL_interface.hh" +#include "STL_timer.hh" +#include <string> +#include "init_function.hh" +#include "init_vector.hh" +#include "init_matrix.hh" + +using namespace std; + +template<class Interface> +class Action_matrix_matrix_product_bis { + +public : + + static inline std::string name( void ) + { + return "matrix_matrix_"+Interface::name(); + } + + static double nb_op_base(int size){ + return 2.0*size*size*size; + } + + static double calculate( int nb_calc, int size ) { + + // STL matrix and vector initialization + + typename Interface::stl_matrix A_stl; + typename Interface::stl_matrix B_stl; + typename Interface::stl_matrix X_stl; + + init_matrix<pseudo_random>(A_stl,size); + init_matrix<pseudo_random>(B_stl,size); + init_matrix<null_function>(X_stl,size); + + // generic matrix and vector initialization + + typename Interface::gene_matrix A_ref; + typename Interface::gene_matrix B_ref; + typename Interface::gene_matrix X_ref; + + typename Interface::gene_matrix A; + typename Interface::gene_matrix B; + typename Interface::gene_matrix X; + + + Interface::matrix_from_stl(A_ref,A_stl); + Interface::matrix_from_stl(B_ref,B_stl); + Interface::matrix_from_stl(X_ref,X_stl); + + Interface::matrix_from_stl(A,A_stl); + Interface::matrix_from_stl(B,B_stl); + Interface::matrix_from_stl(X,X_stl); + + + // STL_timer utilities + + STL_timer chronos; + + // Baseline evaluation + + chronos.start_baseline(nb_calc); + + do { + + Interface::copy_matrix(A_ref,A,size); + Interface::copy_matrix(B_ref,B,size); + Interface::copy_matrix(X_ref,X,size); + + + // Interface::matrix_matrix_product(A,B,X,size); This line must be commented !!!! + } + while(chronos.check()); + + chronos.report(true); + + // Time measurement + + chronos.start(nb_calc); + + do { + + Interface::copy_matrix(A_ref,A,size); + Interface::copy_matrix(B_ref,B,size); + Interface::copy_matrix(X_ref,X,size); + + Interface::matrix_matrix_product(A,B,X,size); // here it is not commented !!!! + } + while(chronos.check()); + + chronos.report(true); + + double time=chronos.calculated_time/2000.0; + + // calculation check + + typename Interface::stl_matrix resu_stl(size); + + Interface::matrix_to_stl(X,resu_stl); + + STL_interface<typename Interface::real_type>::matrix_matrix_product(A_stl,B_stl,X_stl,size); + + typename Interface::real_type error= + STL_interface<typename Interface::real_type>::norm_diff(X_stl,resu_stl); + + if (error>1.e-6){ + INFOS("WRONG CALCULATION...residual=" << error); + exit(1); + } + + // deallocation and return time + + Interface::free_matrix(A,size); + Interface::free_matrix(B,size); + Interface::free_matrix(X,size); + + Interface::free_matrix(A_ref,size); + Interface::free_matrix(B_ref,size); + Interface::free_matrix(X_ref,size); + + return time; + } + +}; + + +#endif + + + diff --git a/btl/actions/action_matrix_vector_product.hh b/btl/actions/action_matrix_vector_product.hh new file mode 100644 index 0000000..8bab79d --- /dev/null +++ b/btl/actions/action_matrix_vector_product.hh @@ -0,0 +1,153 @@ +//===================================================== +// File : action_matrix_vector_product.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, lun sep 30 14:23:19 CEST 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_MATRIX_VECTOR_PRODUCT +#define ACTION_MATRIX_VECTOR_PRODUCT +#include "utilities.h" +#include "STL_interface.hh" +#include <string> +#include "init/init_function.hh" +#include "init/init_vector.hh" +#include "init/init_matrix.hh" + +using namespace std; + +template<class Interface> +class Action_matrix_vector_product { + +public : + + // Ctor + + BTL_DONT_INLINE Action_matrix_vector_product( int size ):_size(size) + { + MESSAGE("Action_matrix_vector_product Ctor"); + + // STL matrix and vector initialization + + init_matrix<pseudo_random>(A_stl,_size); + init_vector<pseudo_random>(B_stl,_size); + init_vector<null_function>(X_stl,_size); + init_vector<null_function>(resu_stl,_size); + + // generic matrix and vector initialization + + Interface::matrix_from_stl(A_ref,A_stl); + Interface::matrix_from_stl(A,A_stl); + Interface::vector_from_stl(B_ref,B_stl); + Interface::vector_from_stl(B,B_stl); + Interface::vector_from_stl(X_ref,X_stl); + Interface::vector_from_stl(X,X_stl); + + } + + // invalidate copy ctor + + Action_matrix_vector_product( const Action_matrix_vector_product & ) + { + INFOS("illegal call to Action_matrix_vector_product Copy Ctor"); + exit(1); + } + + // Dtor + + BTL_DONT_INLINE ~Action_matrix_vector_product( void ){ + + MESSAGE("Action_matrix_vector_product Dtor"); + + // deallocation + + Interface::free_matrix(A,_size); + Interface::free_vector(B); + Interface::free_vector(X); + + Interface::free_matrix(A_ref,_size); + Interface::free_vector(B_ref); + Interface::free_vector(X_ref); + + } + + // action name + + static inline std::string name( void ) + { + return "matrix_vector_" + Interface::name(); + } + + double nb_op_base( void ){ + return 2.0*_size*_size; + } + + BTL_DONT_INLINE void initialize( void ){ + + Interface::copy_matrix(A_ref,A,_size); + Interface::copy_vector(B_ref,B,_size); + Interface::copy_vector(X_ref,X,_size); + + } + + BTL_DONT_INLINE void calculate( void ) { + BTL_ASM_COMMENT("#begin matrix_vector_product"); + Interface::matrix_vector_product(A,B,X,_size); + BTL_ASM_COMMENT("end matrix_vector_product"); + } + + BTL_DONT_INLINE void check_result( void ){ + + // calculation check + + Interface::vector_to_stl(X,resu_stl); + + STL_interface<typename Interface::real_type>::matrix_vector_product(A_stl,B_stl,X_stl,_size); + + typename Interface::real_type error= + STL_interface<typename Interface::real_type>::norm_diff(X_stl,resu_stl); + + if (error>1.e-5){ + INFOS("WRONG CALCULATION...residual=" << error); + exit(0); + } + + } + +private : + + typename Interface::stl_matrix A_stl; + typename Interface::stl_vector B_stl; + typename Interface::stl_vector X_stl; + typename Interface::stl_vector resu_stl; + + typename Interface::gene_matrix A_ref; + typename Interface::gene_vector B_ref; + typename Interface::gene_vector X_ref; + + typename Interface::gene_matrix A; + typename Interface::gene_vector B; + typename Interface::gene_vector X; + + + int _size; + +}; + + +#endif + + + diff --git a/btl/actions/action_parallel_axpy.hh b/btl/actions/action_parallel_axpy.hh new file mode 100644 index 0000000..5053446 --- /dev/null +++ b/btl/actions/action_parallel_axpy.hh @@ -0,0 +1,158 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_PARALLEL_AXPY +#define ACTION_PARALLEL_AXPY +#include "utilities.h" +#include "STL_interface.hh" +#include <string> +#include <algorithm> +#include "init/init_function.hh" +#include "init/init_vector.hh" +#include "init/init_matrix.hh" + +#include "blas.h" + +using namespace std; + +template<class Interface> +class Action_parallel_axpy { +public: + BTL_DONT_INLINE Action_parallel_axpy( int size ):_size(size), _coef(1.) + { + MESSAGE("Action_parallel_axpy Ctor"); + int iZERO = 0, iONE = 1; + + GlobalRows = _size; + GlobalCols = 1; + BlockRows = 2; + BlockCols= 1; + + int myid, procnum; + blacs_pinfo_(&myid, &procnum); + iamroot = (myid == 0); + + // STL matrix and vector initialization + if (iamroot) { + init_vector<pseudo_random>(Global_x_stl, _size); + init_vector<pseudo_random>(Global_y_stl, _size); + } + + Interface::scatter_matrix(Global_x_stl, Local_x_stl, GlobalRows, GlobalCols, BlockRows, BlockCols, LocalRows, LocalCols); + Interface::scatter_matrix(Global_y_stl, Local_y_stl, GlobalRows, GlobalCols, BlockRows, BlockCols, LocalRows, LocalCols); + + Interface::vector_from_stl(Local_x_ref, Local_x_stl); + Interface::vector_from_stl(Local_x , Local_x_stl); + Interface::vector_from_stl(Local_y_ref, Local_y_stl); + Interface::vector_from_stl(Local_y , Local_y_stl); + + // Descinit + int context = Interface::context(); + int info; + int LD = std::max(1, LocalRows); + descinit_(descX, &_size, &iONE, &BlockRows, &BlockCols, &iZERO, &iZERO, &context, &LD, &info); + descinit_(descY, &_size, &iONE, &BlockRows, &BlockCols, &iZERO, &iZERO, &context, &LD, &info); + + // Copy Y to Test_y + Test_y_stl = Global_y_stl; + } + + // Invalidate copy constructor + Action_parallel_axpy (const Action_parallel_axpy&) + { + INFOS("illegal call to Action_parallel_axpy Copy Ctor"); + exit(1); + } + + // Destructor + BTL_DONT_INLINE ~Action_parallel_axpy(){ + + MESSAGE("Action_parallel_axpy Dtor"); + + // deallocation + + Interface::free_vector(Local_x_ref); + Interface::free_vector(Local_y_ref); + + Interface::free_vector(Local_x); + Interface::free_vector(Local_y); + } + + // action name + static inline std::string name() + { + return "axpy_" + Interface::name(); + } + + double nb_op_base( void ){ + return 2.0*_size; + } + + BTL_DONT_INLINE void initialize(){ + Interface::copy_vector(Local_x_ref, Local_x, LocalRows*LocalCols); + Interface::copy_vector(Local_y_ref, Local_y, LocalRows*LocalCols); + } + + BTL_DONT_INLINE void calculate( void ) { + BTL_ASM_COMMENT("#begin axpy"); + Interface::parallel_axpy(_coef, Local_x, descX, Local_y, descY, _size); + BTL_ASM_COMMENT("end axpy"); + } + + void check_result( void ){ + int iONE = 1; + Interface::vector_to_stl(Local_y, Local_y_stl); + Interface::gather_matrix(Global_y_stl, Local_y_stl, GlobalRows, GlobalCols, BlockRows, BlockCols, LocalRows, LocalCols); + + // calculation check + if (iamroot) { + + // Compute YTest + STL_interface<typename Interface::real_type>::axpy(_coef, Global_x_stl, Test_y_stl, _size); + + typename Interface::real_type error = + STL_interface<typename Interface::real_type>::norm_diff(Global_y_stl, Test_y_stl); + + if (error > 1e-5) + std::cerr << "Error: " << error << std::endl; + } + + } + +private: + int _size; + int GlobalRows, GlobalCols, BlockRows, BlockCols, LocalRows, LocalCols; + typename Interface::real_type _coef; + bool iamroot; + + typename Interface::stl_vector Global_x_stl; + typename Interface::stl_vector Global_y_stl; + typename Interface::stl_vector Test_y_stl; + + typename Interface::stl_vector Local_x_stl; + typename Interface::stl_vector Local_y_stl; + + typename Interface::gene_vector Local_x_ref; + typename Interface::gene_vector Local_y_ref; + + typename Interface::gene_vector Local_x; + typename Interface::gene_vector Local_y; + + int descX[9], descY[9]; +}; + +#endif diff --git a/btl/actions/action_parallel_cholesky.hh b/btl/actions/action_parallel_cholesky.hh new file mode 100644 index 0000000..d6bef14 --- /dev/null +++ b/btl/actions/action_parallel_cholesky.hh @@ -0,0 +1,130 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_PARALLEL_CHOLESKY_HH_ +#define ACTION_PARALLEL_CHOLESKY_HH_ + +#include "utilities.h" +#include "init/init_function.hh" +#include "init/init_vector.hh" + +#include "lapack_interface.hh" +#include "STL_interface.hh" + +#include <string> +#include <sstream> +#include <fstream> + +template<class Interface> +class Action_parallel_cholesky { + typedef lapack_interface<typename Interface::real_type> LapackInterface; + +public : + + // Constructor + BTL_DONT_INLINE Action_parallel_cholesky( int size ) : _size(size) + { + MESSAGE("Action_parallel_cholesky Ctor"); + + int myid, procnum; + blacs_pinfo_(&myid, &procnum); + iamroot = (myid == 0); + + // STL matrix and vector initialization + if (iamroot) { + /* Using a constant seed */ + const unsigned seed = 3; + init_SPD_matrix(Global_A_stl, size, seed); + } + + const int blocksize = std::max(std::min(size/4, 64), 2); + scatter_matrix(Global_A_stl, Local_A_stl, desc, size, size, blocksize, blocksize); + LocalRows = desc[8]; + LocalCols = Local_A_stl.size()/desc[8]; + + // Generic local matrix and vectors initialization + Interface::matrix_from_stl(Local_A , Local_A_stl); + + _cost = 0; + for (int j=0; j<_size; ++j) { + double r = std::max(_size - j -1,0); + _cost += 2*(r*j+r+j); + } + } + + + // Invalidate copy constructor + Action_parallel_cholesky(const Action_parallel_cholesky&) + { + INFOS("illegal call to Action_parallel_cholesky copy constructor"); + exit(1); + } + + // Destructor + ~Action_parallel_cholesky() + { + MESSAGE("Action_parallel_cholesky destructor"); + + // Deallocation + Interface::free_matrix(Local_A , Local_A_stl.size()); + } + + // Action name + static inline std::string name() + { + return "cholesky_" + Interface::name(); + } + + double nb_op_base() + { + return _cost; + } + + BTL_DONT_INLINE void initialize() + { + } + + BTL_DONT_INLINE void calculate() + { + Interface::copy_matrix(&Local_A_stl[0], Local_A, Local_A_stl.size()); + Interface::parallel_cholesky(Local_A, desc); + } + + BTL_DONT_INLINE void check_result() + { + if (_size > 2) { + double error = Interface::test_cholesky(Global_A_stl, Local_A, desc); + if (iamroot) + cout << " {error: " << error << "} "; + } + } + + +private: + int _size, desc[9], LocalRows, LocalCols; + double _cost; + bool iamroot; + + typename Interface::stl_matrix Global_A_stl; + typename Interface::stl_matrix Local_A_stl; + typename Interface::gene_matrix Local_A; + + typename Interface::stl_matrix Glotal_Test_stl; + typename Interface::stl_matrix Local_Test_stl; +}; + +#endif /* ACTION_PARALLEL_CHOLESKY_HH_ */ diff --git a/btl/actions/action_parallel_lu_decomp.hh b/btl/actions/action_parallel_lu_decomp.hh new file mode 100644 index 0000000..a6b3600 --- /dev/null +++ b/btl/actions/action_parallel_lu_decomp.hh @@ -0,0 +1,142 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_PARALLEL_LU_DECOMP_HH_ +#define ACTION_PARALLEL_LU_DECOMP_HH_ + +#include "utilities.h" +#include "init/init_function.hh" +#include "init/init_vector.hh" + +#include "lapack_interface.hh" +#include "STL_interface.hh" + +#include <string> + +template<class Interface> +class Action_parallel_lu_decomp { + +public : + + // Constructor + BTL_DONT_INLINE Action_parallel_lu_decomp( int size ) : _size(size) + { + MESSAGE("Action_parallel_lu_decomp Ctor"); + + int myid, procnum; + blacs_pinfo_(&myid, &procnum); + iamroot = (myid == 0); + + // STL matrix and vector initialization + if (iamroot) { + /* Using a constant seed */ + const unsigned seed = 3; + init_matrix(Global_A_stl, size, seed); + } + + const int blocksize = std::max(std::min(size/4, 64), 2); + scatter_matrix(Global_A_stl, Local_A_stl, desc, size, size, blocksize, blocksize); + LocalRows = desc[8]; + LocalCols = Local_A_stl.size()/desc[8]; + + // Generic local matrix and vectors initialization + Interface::matrix_from_stl(Local_A , Local_A_stl); + + _cost = 2.0*size*size*size/3.0 + static_cast<double>(size*size); + } + + + // Invalidate copy constructor + Action_parallel_lu_decomp(const Action_parallel_lu_decomp&) + { + INFOS("illegal call to Action_parallel_lu_decomp copy constructor"); + exit(1); + } + + // Destructor + ~Action_parallel_lu_decomp() + { + MESSAGE("Action_parallel_lu_decomp destructor"); + + // Deallocation + Interface::free_matrix(Local_A , Local_A_stl.size()); + } + + // Action name + static inline std::string name() + { + return "lu_decomp_" + Interface::name(); + } + + double nb_op_base() + { + return _cost; + } + + BTL_DONT_INLINE void initialize() + { + } + + BTL_DONT_INLINE void calculate() + { + Interface::copy_matrix(&Local_A_stl[0], Local_A, Local_A_stl.size()); + Interface::parallel_lu_decomp(Local_A, ipiv_stl, desc); + } + + BTL_DONT_INLINE void check_result() + { +// /* Gather */ +// typename Interface::stl_matrix Global_Y; +// typename Interface::stl_matrix Local_Y(Local_A_stl.size()); +// Interface::matrix_to_stl(Local_A, Local_Y); +// Interface::gather_matrix(Global_Y, Local_Y, desc); +// +// if (iamroot) { +// +// typename Interface::gene_matrix A; +// Interface::matrix_from_stl(A, Global_A_stl); +// lapack_interface<typename Interface::real_type>::lu_decomp(&Global_A_stl[0], A, _size); +// typename Interface::stl_vector correct(A, A+_size*_size); +// typename Interface::real_type error = STL_interface<typename Interface::real_type>::norm_diff(Global_Y, correct); +// if (error > 10e-5) +// cerr << " { !! error : " << error << " !! } "; +// +// Interface::free_matrix(A, _size*_size); +// } + + +// if (_size > 2) { +// double error = Interface::test_LU(Global_A_stl, Local_A, desc); +// if (iamroot) +// cout << " {error: " << error << "} "; +// } + } + +private: + int _size, desc[9], LocalRows, LocalCols; + double _cost; + bool iamroot; + + typename Interface::stl_matrix Global_A_stl; + typename Interface::stl_matrix Local_A_stl; + typename Interface::gene_matrix Local_A; + + std::vector<int> ipiv_stl; +}; + + +#endif /* ACTION_PARALLEL_LU_DECOMP_HH_ */ diff --git a/btl/actions/action_parallel_matrix_vector_product.hh b/btl/actions/action_parallel_matrix_vector_product.hh new file mode 100644 index 0000000..51eafb9 --- /dev/null +++ b/btl/actions/action_parallel_matrix_vector_product.hh @@ -0,0 +1,159 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_PARALLEL_MATRIX_VECTOR_PRODUCT +#define ACTION_PARALLEL_MATRIX_VECTOR_PRODUCT +#include "utilities.h" +#include "STL_interface.hh" +#include <string> +#include <algorithm> +#include "init/init_function.hh" +#include "init/init_vector.hh" +#include "init/init_matrix.hh" + +#include "blas.h" + +template<class Interface> +class Action_parallel_matrix_vector_product { + +public : + + // Ctor + + BTL_DONT_INLINE Action_parallel_matrix_vector_product( int size ):_size(size) + { + MESSAGE("Action_parallel_matrix_vector_product Ctor"); + int iZERO = 0, iONE = 1; + + int myid, procnum; + blacs_pinfo_(&myid, &procnum); + iamroot = (myid == 0); + + // STL matrix and vector initialization + if (iamroot) { + init_vector<pseudo_random>(Global_A_stl, size*size); + init_vector<pseudo_random>(Global_x_stl, size); + init_vector<null_function>(Global_y_stl, size); + } + + const int blocksize = std::max(std::min(size/4, 64), 2); + Interface::scatter_matrix(Global_A_stl, Local_A_stl, descA, size, size, blocksize, blocksize); + Interface::scatter_matrix(Global_x_stl, Local_x_stl, descX, size, 1, blocksize, blocksize); + Interface::scatter_matrix(Global_y_stl, Local_y_stl, descY, size, 1, blocksize, blocksize); + + // generic local matrix and vectors initialization + + Interface::matrix_from_stl(Local_A_ref, Local_A_stl); + Interface::matrix_from_stl(Local_A , Local_A_stl); + Interface::vector_from_stl(Local_x_ref, Local_x_stl); + Interface::vector_from_stl(Local_x , Local_x_stl); + Interface::vector_from_stl(Local_y_ref, Local_y_stl); + Interface::vector_from_stl(Local_y , Local_y_stl); + } + + // invalidate copy ctor + Action_parallel_matrix_vector_product( const Action_parallel_matrix_vector_product & ) + { + INFOS("illegal call to Action_parallel_matrix_vector_product copy constructor"); + exit(1); + } + + // Dtor + BTL_DONT_INLINE ~Action_parallel_matrix_vector_product(){ + + MESSAGE("Action_parallel_matrix_vector_product destructor"); + + // deallocation + + Interface::free_matrix(Local_A_ref, _size*_size); + Interface::free_vector(Local_x_ref); + Interface::free_vector(Local_y_ref); + + Interface::free_matrix(Local_A, _size*_size); + Interface::free_vector(Local_x); + Interface::free_vector(Local_y); + + } + + // action name + static inline std::string name( void ) + { + return "matrix_vector_" + Interface::name(); + } + + double nb_op_base( void ){ + return 2.0*_size*_size; + } + + BTL_DONT_INLINE void initialize( void ){ + Interface::copy_matrix(Local_A_ref, Local_A, Local_A_stl.size()); + Interface::copy_vector(Local_x_ref, Local_x, Local_x_stl.size()); + Interface::copy_vector(Local_y_ref, Local_y, Local_y_stl.size()); + } + + BTL_DONT_INLINE void calculate( void ) { + Interface::parallel_matrix_vector_product(_size, _size, Local_A, descA, Local_x, descX, Local_y, descY); + } + + BTL_DONT_INLINE void check_result( void ){ + int GlobalYCols; + Interface::vector_to_stl(Local_y, Local_y_stl); + + Interface::gather_matrix(Global_y_stl, Local_y_stl, descY); + + // calculation check + if (iamroot) { + + // Compute YTest + Test_y_stl.resize(_size); + STL_interface<typename Interface::real_type>::matrix_vector_product(Global_A_stl, Global_x_stl, Test_y_stl, _size); + + typename Interface::real_type error = STL_interface<typename Interface::real_type>::norm_diff(Global_y_stl, Test_y_stl); + + if (error > 1e-5) + std::cerr << "Error: " << error << " "; + } + + } + +private : + + typename Interface::stl_matrix Global_A_stl; + typename Interface::stl_vector Global_x_stl; + typename Interface::stl_vector Global_y_stl; + typename Interface::stl_vector Test_y_stl; + + typename Interface::stl_matrix Local_A_stl; + typename Interface::stl_vector Local_x_stl; + typename Interface::stl_vector Local_y_stl; + + typename Interface::gene_matrix Local_A_ref; + typename Interface::gene_vector Local_x_ref; + typename Interface::gene_vector Local_y_ref; + + typename Interface::gene_matrix Local_A; + typename Interface::gene_vector Local_x; + typename Interface::gene_vector Local_y; + + bool iamroot; + int _size; + int descA[9], descX[9], descY[9]; + +}; + + +#endif diff --git a/btl/actions/action_parallel_qr_decomp.hh b/btl/actions/action_parallel_qr_decomp.hh new file mode 100644 index 0000000..3c50fb4 --- /dev/null +++ b/btl/actions/action_parallel_qr_decomp.hh @@ -0,0 +1,116 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_PARALLEL_QR_DECOMP_HH_ +#define ACTION_PARALLEL_QR_DECOMP_HH_ + +#include "utilities.h" +#include "init/init_function.hh" +#include "init/init_vector.hh" + +#include "lapack_interface.hh" +#include "STL_interface.hh" + +#include <string> +#include <algorithm> + +template<class Interface> +class Action_parallel_qr_decomp { + +public : + + // Constructor + BTL_DONT_INLINE Action_parallel_qr_decomp( int size ) : _size(size) + { + MESSAGE("Action_parallel_qr_decomp Ctor"); + + int myid, procnum; + blacs_pinfo_(&myid, &procnum); + iamroot = (myid == 0); + + // STL matrix and vector initialization + if (iamroot) { + /* Using a constant seed */ + const unsigned seed = 3; + init_matrix(Global_A_stl, size, seed); + } + + const int blocksize = std::max(std::min(size/4, 64), 2); + scatter_matrix(Global_A_stl, Local_A_stl, desc, size, size, blocksize, blocksize); + LocalRows = desc[8]; + LocalCols = Local_A_stl.size()/desc[8]; + + // Generic local matrix and vectors initialization + Interface::matrix_from_stl(Local_A , Local_A_stl); + + _cost = 2.0*size*size*size; + } + + + // Invalidate copy constructor + Action_parallel_qr_decomp(const Action_parallel_qr_decomp&) + { + INFOS("illegal call to Action_parallel_qr_decomp copy constructor"); + exit(1); + } + + // Destructor + ~Action_parallel_qr_decomp() + { + MESSAGE("Action_parallel_qr_decomp destructor"); + + // Deallocation + Interface::free_matrix(Local_A , Local_A_stl.size()); + } + + // Action name + static inline std::string name() + { + return "qr_decomp_" + Interface::name(); + } + + double nb_op_base() + { + return _cost; + } + + BTL_DONT_INLINE void initialize() + { + } + + BTL_DONT_INLINE void calculate() + { + Interface::copy_matrix(&Local_A_stl[0], Local_A, Local_A_stl.size()); + Interface::parallel_qr_decomp(Local_A, desc); + } + + BTL_DONT_INLINE void check_result() + { + } + +private: + int _size, desc[9], LocalRows, LocalCols; + double _cost; + bool iamroot; + + typename Interface::stl_matrix Global_A_stl; + typename Interface::stl_matrix Local_A_stl; + typename Interface::gene_matrix Local_A; +}; + + +#endif /* ACTION_PARALLEL_QR_DECOMP_HH_ */ diff --git a/btl/actions/action_parallel_svd_decomp.hh b/btl/actions/action_parallel_svd_decomp.hh new file mode 100644 index 0000000..3281886 --- /dev/null +++ b/btl/actions/action_parallel_svd_decomp.hh @@ -0,0 +1,151 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_PARALLEL_SVD_DECOMP_HH_ +#define ACTION_PARALLEL_SVD_DECOMP_HH_ + +#include "utilities.h" +#include "init/init_function.hh" +#include "init/init_vector.hh" + +#include "lapack_interface.hh" +#include "STL_interface.hh" + +#include <string> +#include <algorithm> + +template<class Interface> +class Action_parallel_svd_decomp { + +public : + + // Constructor + BTL_DONT_INLINE Action_parallel_svd_decomp( int size ) : _size(size) + { + MESSAGE("Action_parallel_svd_decomp Ctor"); + + int myid, procnum; + blacs_pinfo_(&myid, &procnum); + iamroot = (myid == 0); + + // STL matrix and vector initialization + if (iamroot) { + init_vector<pseudo_random>(Global_A_stl, size*size); + init_vector<pseudo_random>(Global_U_stl, size*size); + init_vector<pseudo_random>(Global_V_stl, size*size); + } + init_vector<null_function>(Local_s_stl, size); + + const int blocksize = std::max(std::min(size/4, 64), 2); + Interface::scatter_matrix(Global_A_stl, Local_A_stl, descA, size, size, blocksize, blocksize); + Interface::scatter_matrix(Global_U_stl, Local_U_stl, descU, size, size, blocksize, blocksize); + Interface::scatter_matrix(Global_V_stl, Local_V_stl, descV, size, size, blocksize, blocksize); + LocalRows = descA[8]; + LocalCols = Local_A_stl.size()/descA[8]; + + // Generic local matrix and vectors initialization + Interface::matrix_from_stl(Local_A_ref, Local_A_stl); + Interface::matrix_from_stl(Local_A , Local_A_stl); + Interface::matrix_from_stl(Local_U_ref, Local_U_stl); + Interface::matrix_from_stl(Local_U , Local_U_stl); + Interface::matrix_from_stl(Local_V_ref, Local_V_stl); + Interface::matrix_from_stl(Local_V , Local_V_stl); + Interface::vector_from_stl(Local_s_ref, Local_s_stl); + Interface::vector_from_stl(Local_s , Local_s_stl); + + _cost = 2.0*size*size*size; + } + + + // Invalidate copy constructor + Action_parallel_svd_decomp(const Action_parallel_svd_decomp&) + { + INFOS("illegal call to Action_parallel_svd_decomp copy constructor"); + exit(1); + } + + // Destructor + ~Action_parallel_svd_decomp() + { + MESSAGE("Action_parallel_svd_decomp destructor"); + + // Deallocation + Interface::free_matrix(Local_A_ref, Local_A_stl.size()); + Interface::free_matrix(Local_A , Local_A_stl.size()); + Interface::free_matrix(Local_U_ref, Local_U_stl.size()); + Interface::free_matrix(Local_U , Local_U_stl.size()); + Interface::free_matrix(Local_V_ref, Local_V_stl.size()); + Interface::free_matrix(Local_V , Local_V_stl.size()); + Interface::free_vector(Local_s_ref); + Interface::free_vector(Local_s ); + } + + // Action name + static inline std::string name() + { + return "svd_decomp_" + Interface::name(); + } + + double nb_op_base() + { + return _cost; + } + + BTL_DONT_INLINE void initialize() + { + Interface::copy_matrix(Local_A_ref, Local_A, Local_A_stl.size()); + Interface::copy_matrix(Local_U_ref, Local_U, Local_U_stl.size()); + Interface::copy_matrix(Local_V_ref, Local_V, Local_V_stl.size()); + Interface::copy_vector(Local_s_ref, Local_s, Local_s_stl.size()); + } + + BTL_DONT_INLINE void calculate() + { + Interface::parallel_svd_decomp(Local_A, descA, Local_U, descU, Local_V, descV, Local_s); + } + + BTL_DONT_INLINE void check_result() + { + } + +private: + int _size, descA[9], descU[9], descV[9], LocalRows, LocalCols; + double _cost; + bool iamroot; + + typename Interface::stl_matrix Global_A_stl; + typename Interface::stl_matrix Local_A_stl; + typename Interface::gene_matrix Local_A_ref; + typename Interface::gene_matrix Local_A; + + typename Interface::stl_matrix Global_U_stl; + typename Interface::stl_matrix Local_U_stl; + typename Interface::gene_matrix Local_U_ref; + typename Interface::gene_matrix Local_U; + + typename Interface::stl_matrix Global_V_stl; + typename Interface::stl_matrix Local_V_stl; + typename Interface::gene_matrix Local_V_ref; + typename Interface::gene_matrix Local_V; + + typename Interface::stl_vector Local_s_stl; + typename Interface::gene_vector Local_s_ref; + typename Interface::gene_vector Local_s; +}; + + +#endif /* ACTION_PARALLEL_SVD_DECOMP_HH */ diff --git a/btl/actions/action_parallel_symm_ev.hh b/btl/actions/action_parallel_symm_ev.hh new file mode 100644 index 0000000..85a1d13 --- /dev/null +++ b/btl/actions/action_parallel_symm_ev.hh @@ -0,0 +1,138 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_PARALLEL_SYMM_EV_HH_ +#define ACTION_PARALLEL_SYMM_EV_HH_ + +#include "utilities.h" +#include "init/init_function.hh" +#include "init/init_vector.hh" + +#include "lapack_interface.hh" +#include "STL_interface.hh" + +#include <string> + +template<class Interface> +class Action_parallel_symm_ev { + +public : + + // Constructor + BTL_DONT_INLINE Action_parallel_symm_ev( int size ) : _size(size) + { + MESSAGE("Action_parallel_symm_ev constructor"); + + int myid, procnum; + blacs_pinfo_(&myid, &procnum); + iamroot = (myid == 0); + + // STL matrix and vector initialization + if (iamroot) { + init_vector<pseudo_random>(Global_A_stl, size*size); + init_vector<null_function>(Global_Z_stl, size*size); + } + init_vector<null_function>(Local_w_stl, size); + + const int blocksize = std::max(std::min(size/4, 64), 2); + Interface::scatter_matrix(Global_A_stl, Local_A_stl, descA, size, size, blocksize, blocksize); + Interface::scatter_matrix(Global_Z_stl, Local_Z_stl, descZ, size, size, blocksize, blocksize); + LocalRows = descA[8]; + LocalCols = Local_A_stl.size()/descA[8]; + + // Generic local matrix and vectors initialization + Interface::matrix_from_stl(Local_A_ref, Local_A_stl); + Interface::matrix_from_stl(Local_A , Local_A_stl); + Interface::matrix_from_stl(Local_Z_ref, Local_Z_stl); + Interface::matrix_from_stl(Local_Z , Local_Z_stl); + Interface::vector_from_stl(Local_w , Local_w_stl); + Interface::vector_from_stl(Local_w_ref, Local_w_stl); + + _cost = size*size*size; + } + + + // Invalidate copy constructor + Action_parallel_symm_ev(const Action_parallel_symm_ev&) + { + INFOS("illegal call to Action_parallel_symm_ev copy constructor"); + exit(1); + } + + // Destructor + ~Action_parallel_symm_ev() + { + MESSAGE("Action_parallel_symm_ev destructor"); + + // Deallocation + Interface::free_matrix(Local_A_ref, Local_A_stl.size()); + Interface::free_matrix(Local_A , Local_A_stl.size()); + Interface::free_matrix(Local_Z_ref, Local_Z_stl.size()); + Interface::free_matrix(Local_Z , Local_Z_stl.size()); + Interface::free_vector(Local_w_ref); + Interface::free_vector(Local_w ); + } + + // Action name + static inline std::string name() + { + return "symm_ev_" + Interface::name(); + } + + double nb_op_base() + { + return _cost; + } + + BTL_DONT_INLINE void initialize() + { + Interface::copy_matrix(Local_A_ref, Local_A, Local_A_stl.size()); + Interface::copy_matrix(Local_Z_ref, Local_Z, Local_Z_stl.size()); + Interface::copy_vector(Local_w_ref, Local_w, Local_w_stl.size()); + } + + BTL_DONT_INLINE void calculate() + { + Interface::parallel_symm_ev(Local_A, descA, Local_w, Local_Z, descZ); + } + + BTL_DONT_INLINE void check_result() + { + } + +private: + int _size, descA[9], descZ[9], LocalRows, LocalCols; + double _cost; + bool iamroot; + + typename Interface::stl_matrix Global_A_stl; + typename Interface::stl_matrix Local_A_stl; + typename Interface::gene_matrix Local_A_ref; + typename Interface::gene_matrix Local_A; + + typename Interface::stl_matrix Global_Z_stl; + typename Interface::stl_matrix Local_Z_stl; + typename Interface::gene_matrix Local_Z_ref; + typename Interface::gene_matrix Local_Z; + + typename Interface::stl_vector Local_w_stl; + typename Interface::gene_vector Local_w_ref; + typename Interface::gene_vector Local_w; +}; + + +#endif /* ACTION_PARALLEL_SYMM_EV_HH_ */ diff --git a/btl/actions/action_partial_lu.hh b/btl/actions/action_partial_lu.hh new file mode 100644 index 0000000..770ea1d --- /dev/null +++ b/btl/actions/action_partial_lu.hh @@ -0,0 +1,125 @@ +//===================================================== +// File : action_lu_decomp.hh +// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_PARTIAL_LU +#define ACTION_PARTIAL_LU +#include "utilities.h" +#include "STL_interface.hh" +#include <string> +#include "init/init_function.hh" +#include "init/init_vector.hh" +#include "init/init_matrix.hh" + +using namespace std; + +template<class Interface> +class Action_partial_lu { + +public : + + // Ctor + + Action_partial_lu( int size ):_size(size) + { + MESSAGE("Action_partial_lu Ctor"); + + // STL vector initialization + init_matrix<pseudo_random>(X_stl,_size); + init_matrix<null_function>(C_stl,_size); + + // make sure X is invertible + for (int i=0; i<_size; ++i) + X_stl[i][i] = X_stl[i][i] * 1e2 + 1; + + // generic matrix and vector initialization + Interface::matrix_from_stl(X_ref,X_stl); + Interface::matrix_from_stl(X,X_stl); + Interface::matrix_from_stl(C,C_stl); + + _cost = 2.0*size*size*size/3.0 + size*size; + } + + // invalidate copy ctor + + Action_partial_lu( const Action_partial_lu & ) + { + INFOS("illegal call to Action_partial_lu Copy Ctor"); + exit(1); + } + + // Dtor + + ~Action_partial_lu( void ){ + + MESSAGE("Action_partial_lu Dtor"); + + // deallocation + Interface::free_matrix(X_ref,_size); + Interface::free_matrix(X,_size); + Interface::free_matrix(C,_size); + } + + // action name + + static inline std::string name( void ) + { + return "partial_lu_decomp_"+Interface::name(); + } + + double nb_op_base( void ){ + return _cost; + } + + inline void initialize( void ){ + Interface::copy_matrix(X_ref,X,_size); + } + + inline void calculate( void ) { + Interface::partial_lu_decomp(X,C,_size); + } + + void check_result( void ){ + // calculation check +// Interface::matrix_to_stl(C,resu_stl); + +// STL_interface<typename Interface::real_type>::lu_decomp(X_stl,C_stl,_size); +// +// typename Interface::real_type error= +// STL_interface<typename Interface::real_type>::norm_diff(C_stl,resu_stl); +// +// if (error>1.e-6){ +// INFOS("WRONG CALCULATION...residual=" << error); +// exit(0); +// } + + } + +private : + + typename Interface::stl_matrix X_stl; + typename Interface::stl_matrix C_stl; + + typename Interface::gene_matrix X_ref; + typename Interface::gene_matrix X; + typename Interface::gene_matrix C; + + int _size; + double _cost; +}; + +#endif diff --git a/btl/actions/action_qr_decomp.hh b/btl/actions/action_qr_decomp.hh new file mode 100644 index 0000000..15a4619 --- /dev/null +++ b/btl/actions/action_qr_decomp.hh @@ -0,0 +1,112 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_QR_DECOMP +#define ACTION_QR_DECOMP +#include "utilities.h" +#include "STL_interface.hh" +#include <string> +#include "init/init_function.hh" +#include "init/init_vector.hh" +#include "init/init_matrix.hh" + +using namespace std; + +template<class Interface> +class Action_qr_decomp { + +public : + + // Ctor + + Action_qr_decomp( int size ) : _size(size) + { + MESSAGE("Action_qr_decomp Ctor"); + + // STL vector initialization + init_matrix<pseudo_random>(X_stl ,_size); + init_matrix<null_function>(C_stl, _size); + init_vector<null_function>(tau_stl, _size); + + // generic matrix and vector initialization + Interface::matrix_from_stl(X_ref, X_stl); + Interface::matrix_from_stl(X, X_stl); + Interface::matrix_from_stl(C, C_stl); + Interface::vector_from_stl(tau, tau_stl); + + _cost = 2.0*size*size*size/3.0 + size*size + 1.0*size/3.0 - 2; + } + + // invalidate copy ctor + + Action_qr_decomp( const Action_qr_decomp & ) + { + INFOS("illegal call to Action_qr_decomp Copy Ctor"); + exit(1); + } + + // Dtor + + ~Action_qr_decomp( void ){ + + MESSAGE("Action_qr_decomp Dtor"); + + // deallocation + Interface::free_matrix(X_ref, _size); + Interface::free_matrix(X, _size); + Interface::free_matrix(C, _size); + Interface::free_vector(tau); + } + + // action name + + static inline std::string name() + { + return "qr_decomp_"+Interface::name(); + } + + double nb_op_base( void ){ + return _cost; + } + + inline void initialize( void ){ + Interface::copy_matrix(X_ref, X, _size); + } + + inline void calculate( void ) { + Interface::qr_decomp(X, C, tau, _size); + } + + void check_result( void ){ + } + +private : + + typename Interface::stl_matrix X_stl; + typename Interface::stl_matrix C_stl; + typename Interface::stl_vector tau_stl; + + typename Interface::gene_matrix X_ref; + typename Interface::gene_matrix X; + typename Interface::gene_matrix C; + typename Interface::gene_vector tau; + + int _size; + double _cost; +}; + +#endif diff --git a/btl/actions/action_rot.hh b/btl/actions/action_rot.hh new file mode 100644 index 0000000..df822a6 --- /dev/null +++ b/btl/actions/action_rot.hh @@ -0,0 +1,116 @@ + +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_ROT +#define ACTION_ROT +#include "utilities.h" +#include "STL_interface.hh" +#include <string> +#include "init/init_function.hh" +#include "init/init_vector.hh" +#include "init/init_matrix.hh" + +using namespace std; + +template<class Interface> +class Action_rot { + +public : + + // Ctor + BTL_DONT_INLINE Action_rot( int size ):_size(size) + { + MESSAGE("Action_rot Ctor"); + + // STL matrix and vector initialization + typename Interface::stl_matrix tmp; + init_vector<pseudo_random>(A_stl,_size); + init_vector<pseudo_random>(B_stl,_size); + + // generic matrix and vector initialization + Interface::vector_from_stl(A_ref,A_stl); + Interface::vector_from_stl(A,A_stl); + Interface::vector_from_stl(B_ref,B_stl); + Interface::vector_from_stl(B,B_stl); + } + + // invalidate copy ctor + Action_rot( const Action_rot & ) + { + INFOS("illegal call to Action_rot Copy Ctor"); + exit(1); + } + + // Dtor + BTL_DONT_INLINE ~Action_rot( void ){ + MESSAGE("Action_rot Dtor"); + Interface::free_vector(A); + Interface::free_vector(B); + Interface::free_vector(A_ref); + Interface::free_vector(B_ref); + } + + // action name + static inline std::string name( void ) + { + return "rot_" + Interface::name(); + } + + double nb_op_base( void ){ + return 6.0*_size; + } + + BTL_DONT_INLINE void initialize( void ){ + Interface::copy_vector(A_ref,A,_size); + Interface::copy_vector(B_ref,B,_size); + } + + BTL_DONT_INLINE void calculate( void ) { + BTL_ASM_COMMENT("#begin rot"); + Interface::rot(A,B,0.5,0.6,_size); + BTL_ASM_COMMENT("end rot"); + } + + BTL_DONT_INLINE void check_result( void ){ + // calculation check +// Interface::vector_to_stl(X,resu_stl); + +// STL_interface<typename Interface::real_type>::rot(A_stl,B_stl,X_stl,_size); + +// typename Interface::real_type error= +// STL_interface<typename Interface::real_type>::norm_diff(X_stl,resu_stl); + +// if (error>1.e-3){ +// INFOS("WRONG CALCULATION...residual=" << error); +// exit(0); +// } + + } + +private : + + typename Interface::stl_vector A_stl; + typename Interface::stl_vector B_stl; + + typename Interface::gene_vector A_ref; + typename Interface::gene_vector B_ref; + + typename Interface::gene_vector A; + typename Interface::gene_vector B; + + int _size; +}; + + +#endif diff --git a/btl/actions/action_stev.hh b/btl/actions/action_stev.hh new file mode 100644 index 0000000..e564571 --- /dev/null +++ b/btl/actions/action_stev.hh @@ -0,0 +1,119 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_STEV +#define ACTION_STEV +#include "utilities.h" +#include "STL_interface.hh" +#include <string> +#include "init/init_function.hh" +#include "init/init_vector.hh" +#include "init/init_matrix.hh" + +using namespace std; + +template<class Interface> +class Action_stev { + +public : + + // Ctor + + Action_stev( int size ) : _size(size) + { + MESSAGE("Action_stev Ctor"); + + // STL vector initialization + init_vector<pseudo_random>(D_stl, _size); + init_vector<pseudo_random>(E_stl, max(0, _size-1)); + init_matrix<null_function>(V_stl, _size); + init_vector<null_function>(W_stl, _size); + + // generic matrix and vector initialization + Interface::vector_from_stl(D_ref, D_stl); + Interface::vector_from_stl(E_ref, E_stl); + Interface::vector_from_stl(D, D_stl); + Interface::vector_from_stl(E, E_stl); + Interface::matrix_from_stl(V, V_stl); + Interface::vector_from_stl(W, W_stl); + + // FIXME: correct? + _cost = size*size*size; + } + + // invalidate copy ctor + + Action_stev( const Action_stev& ) + { + INFOS("illegal call to Action_stev Copy Ctor"); + exit(1); + } + + // Dtor + + ~Action_stev( void ){ + + MESSAGE("Action_stev Dtor"); + + // deallocation + Interface::free_vector(D_ref); + Interface::free_vector(E_ref); + Interface::free_vector(D); + Interface::free_vector(E); + Interface::free_matrix(V, _size); + Interface::free_vector(W); + } + + // action name + + static inline std::string name() + { + return "stev_"+Interface::name(); + } + + double nb_op_base( void ){ + return _cost; + } + + inline void initialize( void ){ + Interface::copy_vector(D_ref, D, _size); + Interface::copy_vector(E_ref, E, _size-1); + } + + inline void calculate( void ) { + Interface::stev(D, E, W, V, _size); + } + + void check_result( void ){ + } + +private : + + typename Interface::stl_vector D_stl, E_stl; + typename Interface::stl_matrix V_stl; + typename Interface::stl_vector W_stl; + + typename Interface::gene_vector D_ref, E_ref; + typename Interface::gene_vector D, E; + typename Interface::gene_matrix V; + typename Interface::gene_vector W; + + int _size; + double _cost; +}; + +#endif diff --git a/btl/actions/action_svd_decomp.hh b/btl/actions/action_svd_decomp.hh new file mode 100644 index 0000000..be6740a --- /dev/null +++ b/btl/actions/action_svd_decomp.hh @@ -0,0 +1,115 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_SVD_DECOMP +#define ACTION_SVD_DECOMP +#include "utilities.h" +#include "STL_interface.hh" +#include <string> +#include "init/init_function.hh" +#include "init/init_vector.hh" +#include "init/init_matrix.hh" + +using namespace std; + +template<class Interface> +class Action_svd_decomp { + +public : + + // Ctor + + Action_svd_decomp( int size ) : _size(size) + { + MESSAGE("Action_svd_decomp Ctor"); + + // STL vector initialization + init_matrix<pseudo_random>(X_stl ,_size); + init_matrix<null_function>(U_stl, _size); + init_matrix<null_function>(VT_stl, _size); + init_vector<null_function>(S_stl, _size); + + // generic matrix and vector initialization + Interface::matrix_from_stl(X_ref, X_stl); + Interface::matrix_from_stl(X, X_stl); + Interface::matrix_from_stl(U, U_stl); + Interface::matrix_from_stl(VT, VT_stl); + Interface::vector_from_stl(S, S_stl); + + _cost = 4*size*size*size; + } + + // invalidate copy ctor + + Action_svd_decomp( const Action_svd_decomp & ) + { + INFOS("illegal call to Action_svd_decomp Copy Ctor"); + exit(1); + } + + // Dtor + + ~Action_svd_decomp( void ){ + + MESSAGE("Action_svd_decomp Dtor"); + + // deallocation + Interface::free_matrix(X_ref, _size); + Interface::free_matrix(X, _size); + Interface::free_matrix(U, _size); + Interface::free_matrix(VT, _size); + Interface::free_vector(S); + } + + // action name + + static inline std::string name() + { + return "svd_decomp_"+Interface::name(); + } + + double nb_op_base( void ){ + return _cost; + } + + inline void initialize( void ){ + Interface::copy_matrix(X_ref, X, _size); + } + + inline void calculate( void ) { + Interface::svd_decomp(X, U, S, VT, _size); + } + + void check_result( void ){ + } + +private : + + typename Interface::stl_matrix X_stl; + typename Interface::stl_matrix U_stl, VT_stl; + typename Interface::stl_vector S_stl; + + typename Interface::gene_matrix X_ref; + typename Interface::gene_matrix X; + typename Interface::gene_matrix U, VT; + typename Interface::gene_vector S; + + int _size; + double _cost; +}; + +#endif diff --git a/btl/actions/action_syev.hh b/btl/actions/action_syev.hh new file mode 100644 index 0000000..b8f33be --- /dev/null +++ b/btl/actions/action_syev.hh @@ -0,0 +1,113 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_SYEV +#define ACTION_SYEV +#include "utilities.h" +#include "STL_interface.hh" +#include <string> +#include "init/init_function.hh" +#include "init/init_vector.hh" +#include "init/init_matrix.hh" + +using namespace std; + +template<class Interface> +class Action_syev { + +public : + + // Ctor + + Action_syev( int size ) : _size(size) + { + MESSAGE("Action_syev Ctor"); + + // STL vector initialization + init_matrix_symm<pseudo_random>(X_stl ,_size); + init_matrix<null_function>(V_stl, _size); + init_vector<null_function>(W_stl, _size); + + // generic matrix and vector initialization + Interface::matrix_from_stl(X_ref, X_stl); + Interface::matrix_from_stl(X, X_stl); + Interface::matrix_from_stl(V, V_stl); + Interface::vector_from_stl(W, W_stl); + + // FIXME: correct? + _cost = size*size*size; + } + + // invalidate copy ctor + + Action_syev( const Action_syev& ) + { + INFOS("illegal call to Action_syev Copy Ctor"); + exit(1); + } + + // Dtor + + ~Action_syev( void ){ + + MESSAGE("Action_syev Dtor"); + + // deallocation + Interface::free_matrix(X_ref, _size); + Interface::free_matrix(X, _size); + Interface::free_matrix(V, _size); + Interface::free_vector(W); + } + + // action name + + static inline std::string name() + { + return "syev_"+Interface::name(); + } + + double nb_op_base( void ){ + return _cost; + } + + inline void initialize( void ){ + Interface::copy_matrix(X_ref, X, _size); + } + + inline void calculate( void ) { + Interface::syev(X, V, W, _size); + } + + void check_result( void ){ + } + +private : + + typename Interface::stl_matrix X_stl; + typename Interface::stl_matrix V_stl; + typename Interface::stl_vector W_stl; + + typename Interface::gene_matrix X_ref; + typename Interface::gene_matrix X; + typename Interface::gene_matrix V; + typename Interface::gene_vector W; + + int _size; + double _cost; +}; + +#endif diff --git a/btl/actions/action_symm_ev.hh b/btl/actions/action_symm_ev.hh new file mode 100644 index 0000000..c696da2 --- /dev/null +++ b/btl/actions/action_symm_ev.hh @@ -0,0 +1,104 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_SYMM_EV +#define ACTION_SYMM_EV + +#include "utilities.h" +#include "STL_interface.hh" +#include <string> +#include "init/init_function.hh" +#include "init/init_vector.hh" +#include "init/init_matrix.hh" + +template<class Interface> +class Action_symm_ev { + +public: + + // Ctor + Action_symm_ev( int size ) : _size(size) + { + MESSAGE("Action_symm_ev Ctor"); + + // STL matrix initialization + init_matrix_symm<pseudo_random>(X_stl,_size); + init_vector<pseudo_random>(W_stl,_size); + + // generic matrix and vector initialization + Interface::matrix_from_stl(X,X_stl); + Interface::vector_from_stl(W,W_stl); + + + } + + // invalidate copy ctor + + Action_symm_ev( const Action_symm_ev & ) + { + INFOS("illegal call to Action_symm_ev Copy Ctor"); + exit(1); + } + + // Dtor + + ~Action_symm_ev( void ){ + + MESSAGE("Action_symm_ev Dtor"); + + // deallocation + Interface::free_matrix(X,_size); + } + + // action name + + static inline std::string name( void ) + { + return "symm_ev_"+Interface::name(); + } + + double nb_op_base( void ){ + // TODO: is this right? + return _size*_size; + } + + inline void initialize( void ){ + } + + inline void calculate( void ) { + Interface::symm_ev(X,W,_size); + } + + void check_result( void ) { + // TODO: check result + } + +private : + + typename Interface::stl_matrix X_stl; + typename Interface::stl_vector W_stl; + + typename Interface::gene_matrix X; + typename Interface::gene_vector W; + + int _size; + double _cost; + +}; + + +#endif // ACTION_SYMM_EV diff --git a/btl/actions/action_symv.hh b/btl/actions/action_symv.hh new file mode 100644 index 0000000..a32b9df --- /dev/null +++ b/btl/actions/action_symv.hh @@ -0,0 +1,139 @@ +//===================================================== +// File : action_symv.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, lun sep 30 14:23:19 CEST 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_SYMV +#define ACTION_SYMV +#include "utilities.h" +#include "STL_interface.hh" +#include <string> +#include "init/init_function.hh" +#include "init/init_vector.hh" +#include "init/init_matrix.hh" + +using namespace std; + +template<class Interface> +class Action_symv { + +public : + + // Ctor + + BTL_DONT_INLINE Action_symv( int size ):_size(size) + { + MESSAGE("Action_symv Ctor"); + + // STL matrix and vector initialization + init_matrix_symm<pseudo_random>(A_stl,_size); + init_vector<pseudo_random>(B_stl,_size); + init_vector<null_function>(X_stl,_size); + init_vector<null_function>(resu_stl,_size); + + // generic matrix and vector initialization + Interface::matrix_from_stl(A_ref,A_stl); + Interface::matrix_from_stl(A,A_stl); + Interface::vector_from_stl(B_ref,B_stl); + Interface::vector_from_stl(B,B_stl); + Interface::vector_from_stl(X_ref,X_stl); + Interface::vector_from_stl(X,X_stl); + + } + + // invalidate copy ctor + + Action_symv( const Action_symv & ) + { + INFOS("illegal call to Action_symv Copy Ctor"); + exit(1); + } + + // Dtor + BTL_DONT_INLINE ~Action_symv( void ){ + Interface::free_matrix(A,_size); + Interface::free_vector(B); + Interface::free_vector(X); + Interface::free_matrix(A_ref,_size); + Interface::free_vector(B_ref); + Interface::free_vector(X_ref); + } + + // action name + + static inline std::string name( void ) + { + return "symv_" + Interface::name(); + } + + double nb_op_base( void ){ + return 2.0*_size*_size; + } + + BTL_DONT_INLINE void initialize( void ){ + + Interface::copy_matrix(A_ref,A,_size); + Interface::copy_vector(B_ref,B,_size); + Interface::copy_vector(X_ref,X,_size); + + } + + BTL_DONT_INLINE void calculate( void ) { + BTL_ASM_COMMENT("#begin symv"); + Interface::symv(A,B,X,_size); + BTL_ASM_COMMENT("end symv"); + } + + BTL_DONT_INLINE void check_result( void ){ + if (_size>128) return; + // calculation check + Interface::vector_to_stl(X,resu_stl); + + STL_interface<typename Interface::real_type>::symv(A_stl,B_stl,X_stl,_size); + + typename Interface::real_type error= + STL_interface<typename Interface::real_type>::norm_diff(X_stl,resu_stl); + + if (error>1.e-5){ + INFOS("WRONG CALCULATION...residual=" << error); + exit(0); + } + + } + +private : + + typename Interface::stl_matrix A_stl; + typename Interface::stl_vector B_stl; + typename Interface::stl_vector X_stl; + typename Interface::stl_vector resu_stl; + + typename Interface::gene_matrix A_ref; + typename Interface::gene_vector B_ref; + typename Interface::gene_vector X_ref; + + typename Interface::gene_matrix A; + typename Interface::gene_vector B; + typename Interface::gene_vector X; + + + int _size; + +}; + + +#endif diff --git a/btl/actions/action_syr2.hh b/btl/actions/action_syr2.hh new file mode 100644 index 0000000..7c6712b --- /dev/null +++ b/btl/actions/action_syr2.hh @@ -0,0 +1,133 @@ +//===================================================== +// File : action_syr2.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, lun sep 30 14:23:19 CEST 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_SYR2 +#define ACTION_SYR2 +#include "utilities.h" +#include "STL_interface.hh" +#include <string> +#include "init/init_function.hh" +#include "init/init_vector.hh" +#include "init/init_matrix.hh" + +using namespace std; + +template<class Interface> +class Action_syr2 { + +public : + + // Ctor + + BTL_DONT_INLINE Action_syr2( int size ):_size(size) + { + // STL matrix and vector initialization + typename Interface::stl_matrix tmp; + init_matrix<pseudo_random>(A_stl,_size); + init_vector<pseudo_random>(B_stl,_size); + init_vector<pseudo_random>(X_stl,_size); + init_vector<null_function>(resu_stl,_size); + + // generic matrix and vector initialization + Interface::matrix_from_stl(A_ref,A_stl); + Interface::matrix_from_stl(A,A_stl); + Interface::vector_from_stl(B_ref,B_stl); + Interface::vector_from_stl(B,B_stl); + Interface::vector_from_stl(X_ref,X_stl); + Interface::vector_from_stl(X,X_stl); + } + + // invalidate copy ctor + Action_syr2( const Action_syr2 & ) + { + INFOS("illegal call to Action_syr2 Copy Ctor"); + exit(1); + } + + // Dtor + BTL_DONT_INLINE ~Action_syr2( void ){ + Interface::free_matrix(A,_size); + Interface::free_vector(B); + Interface::free_vector(X); + Interface::free_matrix(A_ref,_size); + Interface::free_vector(B_ref); + Interface::free_vector(X_ref); + } + + // action name + + static inline std::string name( void ) + { + return "syr2_" + Interface::name(); + } + + double nb_op_base( void ){ + return 2.0*_size*_size; + } + + BTL_DONT_INLINE void initialize( void ){ + Interface::copy_matrix(A_ref,A,_size); + Interface::copy_vector(B_ref,B,_size); + Interface::copy_vector(X_ref,X,_size); + } + + BTL_DONT_INLINE void calculate( void ) { + BTL_ASM_COMMENT("#begin syr2"); + Interface::syr2(A,B,X,_size); + BTL_ASM_COMMENT("end syr2"); + } + + BTL_DONT_INLINE void check_result( void ){ + // calculation check + Interface::vector_to_stl(X,resu_stl); + + STL_interface<typename Interface::real_type>::syr2(A_stl,B_stl,X_stl,_size); + + typename Interface::real_type error= + STL_interface<typename Interface::real_type>::norm_diff(X_stl,resu_stl); + + if (error>1.e-3){ + INFOS("WRONG CALCULATION...residual=" << error); +// exit(0); + } + + } + +private : + + typename Interface::stl_matrix A_stl; + typename Interface::stl_vector B_stl; + typename Interface::stl_vector X_stl; + typename Interface::stl_vector resu_stl; + + typename Interface::gene_matrix A_ref; + typename Interface::gene_vector B_ref; + typename Interface::gene_vector X_ref; + + typename Interface::gene_matrix A; + typename Interface::gene_vector B; + typename Interface::gene_vector X; + + + int _size; + +}; + + +#endif diff --git a/btl/actions/action_trisolve.hh b/btl/actions/action_trisolve.hh new file mode 100644 index 0000000..d6f0b47 --- /dev/null +++ b/btl/actions/action_trisolve.hh @@ -0,0 +1,137 @@ +//===================================================== +// File : action_trisolve.hh +// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_TRISOLVE +#define ACTION_TRISOLVE +#include "utilities.h" +#include "STL_interface.hh" +#include <string> +#include "init/init_function.hh" +#include "init/init_vector.hh" +#include "init/init_matrix.hh" + +using namespace std; + +template<class Interface> +class Action_trisolve { + +public : + + // Ctor + + Action_trisolve( int size ):_size(size) + { + MESSAGE("Action_trisolve Ctor"); + + // STL vector initialization + init_matrix<pseudo_random>(L_stl,_size); + init_vector<pseudo_random>(B_stl,_size); + init_vector<null_function>(X_stl,_size); + for (int j=0; j<_size; ++j) + { + for (int i=0; i<j; ++i) + L_stl[j][i] = 0; + L_stl[j][j] += 3; + } + + init_vector<null_function>(resu_stl,_size); + + // generic matrix and vector initialization + Interface::matrix_from_stl(L,L_stl); + Interface::vector_from_stl(X,X_stl); + Interface::vector_from_stl(B,B_stl); + + _cost = 0; + for (int j=0; j<_size; ++j) + { + _cost += 2*j + 1; + } + } + + // invalidate copy ctor + + Action_trisolve( const Action_trisolve & ) + { + INFOS("illegal call to Action_trisolve Copy Ctor"); + exit(1); + } + + // Dtor + + ~Action_trisolve( void ){ + + MESSAGE("Action_trisolve Dtor"); + + // deallocation + Interface::free_matrix(L,_size); + Interface::free_vector(B); + Interface::free_vector(X); + } + + // action name + + static inline std::string name( void ) + { + return "trisolve_vector_"+Interface::name(); + } + + double nb_op_base( void ){ + return _cost; + } + + inline void initialize( void ){ + //Interface::copy_vector(X_ref,X,_size); + } + + inline void calculate( void ) { + Interface::trisolve_lower(L,B,X,_size); + } + + void check_result(){ + if (_size>128) return; + // calculation check + Interface::vector_to_stl(X,resu_stl); + + STL_interface<typename Interface::real_type>::trisolve_lower(L_stl,B_stl,X_stl,_size); + + typename Interface::real_type error= + STL_interface<typename Interface::real_type>::norm_diff(X_stl,resu_stl); + + if (error>1.e-4){ + INFOS("WRONG CALCULATION...residual=" << error); + exit(2); + } //else INFOS("CALCULATION OK...residual=" << error); + + } + +private : + + typename Interface::stl_matrix L_stl; + typename Interface::stl_vector X_stl; + typename Interface::stl_vector B_stl; + typename Interface::stl_vector resu_stl; + + typename Interface::gene_matrix L; + typename Interface::gene_vector X; + typename Interface::gene_vector B; + + int _size; + double _cost; +}; + +#endif diff --git a/btl/actions/action_trisolve_matrix.hh b/btl/actions/action_trisolve_matrix.hh new file mode 100644 index 0000000..0fc2bb9 --- /dev/null +++ b/btl/actions/action_trisolve_matrix.hh @@ -0,0 +1,165 @@ +//===================================================== +// File : action_matrix_matrix_product.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, lun sep 30 14:23:19 CEST 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_TRISOLVE_MATRIX_PRODUCT +#define ACTION_TRISOLVE_MATRIX_PRODUCT +#include "utilities.h" +#include "STL_interface.hh" +#include <string> +#include "init/init_function.hh" +#include "init/init_vector.hh" +#include "init/init_matrix.hh" + +using namespace std; + +template<class Interface> +class Action_trisolve_matrix { + +public : + + // Ctor + + Action_trisolve_matrix( int size ):_size(size) + { + MESSAGE("Action_trisolve_matrix Ctor"); + + // STL matrix and vector initialization + + init_matrix<pseudo_random>(A_stl,_size); + init_matrix<pseudo_random>(B_stl,_size); + init_matrix<null_function>(X_stl,_size); + init_matrix<null_function>(resu_stl,_size); + + for (int j=0; j<_size; ++j) + { + for (int i=0; i<j; ++i) + A_stl[j][i] = 0; + A_stl[j][j] += 3; + } + + // generic matrix and vector initialization + + Interface::matrix_from_stl(A_ref,A_stl); + Interface::matrix_from_stl(B_ref,B_stl); + Interface::matrix_from_stl(X_ref,X_stl); + + Interface::matrix_from_stl(A,A_stl); + Interface::matrix_from_stl(B,B_stl); + Interface::matrix_from_stl(X,X_stl); + + _cost = 0; + for (int j=0; j<_size; ++j) + { + _cost += 2*j + 1; + } + _cost *= _size; + } + + // invalidate copy ctor + + Action_trisolve_matrix( const Action_trisolve_matrix & ) + { + INFOS("illegal call to Action_trisolve_matrix Copy Ctor"); + exit(0); + } + + // Dtor + + ~Action_trisolve_matrix( void ){ + + MESSAGE("Action_trisolve_matrix Dtor"); + + // deallocation + + Interface::free_matrix(A,_size); + Interface::free_matrix(B,_size); + Interface::free_matrix(X,_size); + + Interface::free_matrix(A_ref,_size); + Interface::free_matrix(B_ref,_size); + Interface::free_matrix(X_ref,_size); + + } + + // action name + + static inline std::string name( void ) + { + return "trisolve_matrix_"+Interface::name(); + } + + double nb_op_base( void ){ + return _cost; + } + + inline void initialize( void ){ + + Interface::copy_matrix(A_ref,A,_size); + Interface::copy_matrix(B_ref,B,_size); + Interface::copy_matrix(X_ref,X,_size); + + } + + inline void calculate( void ) { + Interface::trisolve_lower_matrix(A,B,X,_size); + } + + void check_result( void ){ + + // calculation check + +// Interface::matrix_to_stl(X,resu_stl); +// +// STL_interface<typename Interface::real_type>::matrix_matrix_product(A_stl,B_stl,X_stl,_size); +// +// typename Interface::real_type error= +// STL_interface<typename Interface::real_type>::norm_diff(X_stl,resu_stl); +// +// if (error>1.e-6){ +// INFOS("WRONG CALCULATION...residual=" << error); +// // exit(1); +// } + + } + +private : + + typename Interface::stl_matrix A_stl; + typename Interface::stl_matrix B_stl; + typename Interface::stl_matrix X_stl; + typename Interface::stl_matrix resu_stl; + + typename Interface::gene_matrix A_ref; + typename Interface::gene_matrix B_ref; + typename Interface::gene_matrix X_ref; + + typename Interface::gene_matrix A; + typename Interface::gene_matrix B; + typename Interface::gene_matrix X; + + int _size; + double _cost; + +}; + + +#endif + + + diff --git a/btl/actions/action_trmm.hh b/btl/actions/action_trmm.hh new file mode 100644 index 0000000..8f78138 --- /dev/null +++ b/btl/actions/action_trmm.hh @@ -0,0 +1,165 @@ +//===================================================== +// File : action_matrix_matrix_product.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, lun sep 30 14:23:19 CEST 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_TRMM +#define ACTION_TRMM +#include "utilities.h" +#include "STL_interface.hh" +#include <string> +#include "init/init_function.hh" +#include "init/init_vector.hh" +#include "init/init_matrix.hh" + +using namespace std; + +template<class Interface> +class Action_trmm { + +public : + + // Ctor + + Action_trmm( int size ):_size(size) + { + MESSAGE("Action_trmm Ctor"); + + // STL matrix and vector initialization + + init_matrix<pseudo_random>(A_stl,_size); + init_matrix<pseudo_random>(B_stl,_size); + init_matrix<null_function>(X_stl,_size); + init_matrix<null_function>(resu_stl,_size); + + for (int j=0; j<_size; ++j) + { + for (int i=0; i<j; ++i) + A_stl[j][i] = 0; + A_stl[j][j] += 3; + } + + // generic matrix and vector initialization + + Interface::matrix_from_stl(A_ref,A_stl); + Interface::matrix_from_stl(B_ref,B_stl); + Interface::matrix_from_stl(X_ref,X_stl); + + Interface::matrix_from_stl(A,A_stl); + Interface::matrix_from_stl(B,B_stl); + Interface::matrix_from_stl(X,X_stl); + + _cost = 0; + for (int j=0; j<_size; ++j) + { + _cost += 2*j + 1; + } + _cost *= _size; + } + + // invalidate copy ctor + + Action_trmm( const Action_trmm & ) + { + INFOS("illegal call to Action_trmm Copy Ctor"); + exit(0); + } + + // Dtor + + ~Action_trmm( void ){ + + MESSAGE("Action_trmm Dtor"); + + // deallocation + + Interface::free_matrix(A,_size); + Interface::free_matrix(B,_size); + Interface::free_matrix(X,_size); + + Interface::free_matrix(A_ref,_size); + Interface::free_matrix(B_ref,_size); + Interface::free_matrix(X_ref,_size); + + } + + // action name + + static inline std::string name( void ) + { + return "trmm_"+Interface::name(); + } + + double nb_op_base( void ){ + return _cost; + } + + inline void initialize( void ){ + + Interface::copy_matrix(A_ref,A,_size); + Interface::copy_matrix(B_ref,B,_size); + Interface::copy_matrix(X_ref,X,_size); + + } + + inline void calculate( void ) { + Interface::trmm(A,B,X,_size); + } + + void check_result( void ){ + + // calculation check + +// Interface::matrix_to_stl(X,resu_stl); +// +// STL_interface<typename Interface::real_type>::matrix_matrix_product(A_stl,B_stl,X_stl,_size); +// +// typename Interface::real_type error= +// STL_interface<typename Interface::real_type>::norm_diff(X_stl,resu_stl); +// +// if (error>1.e-6){ +// INFOS("WRONG CALCULATION...residual=" << error); +// // exit(1); +// } + + } + +private : + + typename Interface::stl_matrix A_stl; + typename Interface::stl_matrix B_stl; + typename Interface::stl_matrix X_stl; + typename Interface::stl_matrix resu_stl; + + typename Interface::gene_matrix A_ref; + typename Interface::gene_matrix B_ref; + typename Interface::gene_matrix X_ref; + + typename Interface::gene_matrix A; + typename Interface::gene_matrix B; + typename Interface::gene_matrix X; + + int _size; + double _cost; + +}; + + +#endif + + + diff --git a/btl/actions/base_action_fftw.hh b/btl/actions/base_action_fftw.hh new file mode 100644 index 0000000..fb32b51 --- /dev/null +++ b/btl/actions/base_action_fftw.hh @@ -0,0 +1,86 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef BASE_ACTION_FFTW_HH +#define BASE_ACTION_FFTW_HH + +#include "utilities.h" +#include "init/init_function.hh" +#include "init/init_vector.hh" + +inline int power(const int& base, const int& exp) { + int ret = 1; + for (int i = 0; i < exp; ++i) + ret *= base; + return ret; +} + +template<class Interface> +class Action_FFTW_base +{ +public: + // Constructor + Action_FFTW_base(const int& size, const int& dimensions) : + size_(size), dimensions_(dimensions), N_(power(size, dimensions)) + { + // STL vector initialization + init_vector < pseudo_random > (X_stl, N_); + init_vector < null_function > (Y_stl, N_); + + // Generic vector initialization + Interface::vector_from_stl(X, X_stl); + Interface::vector_from_stl(Y, Y_stl); + + // To be done by the child: + /* initialize plan! */ + } + + // Invalidate copy constructor + Action_FFTW_base( const Action_FFTW_base & ) + { + INFOS("illegal call to Action_FFTW_base Copy Ctor"); + exit(1); + } + + // Destructor: + // frees the memory + ~Action_FFTW_base() + { + Interface::free_vector(X); + Interface::free_vector(Y); + } + + inline void initialize() { } + + inline void calculate( void ) { + Interface::fftw_run(p); + } + + void check_result( void ){ + } + + +protected: + const int size_, dimensions_, N_; + + typename Interface::stl_vector X_stl, Y_stl; + typename Interface::gene_vector X, Y; + + typename Interface::plan p; +}; + +#endif /* BASE_ACTION_FFTW_HH */ diff --git a/btl/actions/basic_actions.hh b/btl/actions/basic_actions.hh new file mode 100644 index 0000000..a3333ea --- /dev/null +++ b/btl/actions/basic_actions.hh @@ -0,0 +1,21 @@ + +#include "action_axpy.hh" +#include "action_axpby.hh" + +#include "action_matrix_vector_product.hh" +#include "action_atv_product.hh" + +#include "action_matrix_matrix_product.hh" +// #include "action_ata_product.hh" +#include "action_aat_product.hh" + +#include "action_trisolve.hh" +#include "action_trmm.hh" +#include "action_symv.hh" +// #include "action_symm.hh" +#include "action_syr2.hh" +#include "action_ger.hh" +#include "action_rot.hh" + +// #include "action_lu_solve.hh" + diff --git a/btl/actions/fftw_actions.hh b/btl/actions/fftw_actions.hh new file mode 100644 index 0000000..b7a6f35 --- /dev/null +++ b/btl/actions/fftw_actions.hh @@ -0,0 +1,26 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef ACTION_FFTW +#define ACTION_FFTW + +#include "base_action_fftw.hh" +#include "action_fftw_1d.hh" +#include "action_fftw_2d.hh" +#include "action_fftw_3d.hh" + +#endif // ACTION_FFTW diff --git a/btl/data/action_settings.txt b/btl/data/action_settings.txt new file mode 100644 index 0000000..da80f56 --- /dev/null +++ b/btl/data/action_settings.txt @@ -0,0 +1,18 @@ +aat ; "{/*1.5 A x A^T}" ; "matrix size" ; 4:3000 +ata ; "{/*1.5 A^T x A}" ; "matrix size" ; 4:3000 +atv ; "{/*1.5 matrix^T x vector}" ; "matrix size" ; 4:3000 +axpby ; "{/*1.5 Y = alpha X + beta Y}" ; "vector size" ; 5:1000000 +axpy ; "{/*1.5 Y += alpha X}" ; "vector size" ; 5:1000000 +matrix_matrix ; "{/*1.5 matrix matrix product}" ; "matrix size" ; 4:3000 +matrix_vector ; "{/*1.5 matrix vector product}" ; "matrix size" ; 4:3000 +trisolve_vector ; "{/*1.5 triangular solver - vector (X = inv(L) X)}" ; "size" ; 4:3000 +trisolve_matrix ; "{/*1.5 triangular solver - matrix (M = inv(L) M)}" ; "size" ; 4:3000 +cholesky ; "{/*1.5 Cholesky decomposition}" ; "matrix size" ; 4:3000 +complete_lu_decomp ; "{/*1.5 Complete LU decomposition}" ; "matrix size" ; 4:3000 +partial_lu_decomp ; "{/*1.5 Partial LU decomposition}" ; "matrix size" ; 4:3000 +tridiagonalization ; "{/*1.5 Tridiagonalization}" ; "matrix size" ; 4:3000 +hessenberg ; "{/*1.5 Hessenberg decomposition}" ; "matrix size" ; 4:3000 +symv ; "{/*1.5 symmetric matrix vector product}" ; "matrix size" ; 4:3000 +syr2 ; "{/*1.5 symmretric rank-2 update (A += u^T v + u v^T)}" ; "matrix size" ; 4:3000 +ger ; "{/*1.5 general rank-1 update (A += u v^T)}" ; "matrix size" ; 4:3000 +rot ; "{/*1.5 apply rotation in the plane}" ; "vector size" ; 4:1000000
\ No newline at end of file diff --git a/btl/data/gnuplot_common_settings.hh b/btl/data/gnuplot_common_settings.hh new file mode 100644 index 0000000..6f677df --- /dev/null +++ b/btl/data/gnuplot_common_settings.hh @@ -0,0 +1,87 @@ +set noclip points +set clip one +set noclip two +set bar 1.000000 +set border 31 lt -1 lw 1.000 +set xdata +set ydata +set zdata +set x2data +set y2data +set boxwidth +set dummy x,y +set format x "%g" +set format y "%g" +set format x2 "%g" +set format y2 "%g" +set format z "%g" +set angles radians +set nogrid +set key title "" +set key left top Right noreverse box linetype -2 linewidth 1.000 samplen 4 spacing 1 width 0 +set nolabel +set noarrow +# set nolinestyle # deprecated +set nologscale +set logscale x 10 +set offsets 0, 0, 0, 0 +set pointsize 1 +set encoding default +set nopolar +set noparametric +set view 60, 30, 1, 1 +set samples 100, 100 +set isosamples 10, 10 +set surface +set nocontour +set clabel '%8.3g' +set mapping cartesian +set nohidden3d +set cntrparam order 4 +set cntrparam linear +set cntrparam levels auto 5 +set cntrparam points 5 +set size ratio 0 1,1 +set origin 0,0 +# set data style lines +# set function style lines +set xzeroaxis lt -2 lw 1.000 +set x2zeroaxis lt -2 lw 1.000 +set yzeroaxis lt -2 lw 1.000 +set y2zeroaxis lt -2 lw 1.000 +set tics in +set ticslevel 0.5 +set tics scale 1, 0.5 +set mxtics default +set mytics default +set mx2tics default +set my2tics default +set xtics border mirror norotate autofreq +set ytics border mirror norotate autofreq +set ztics border nomirror norotate autofreq +set nox2tics +set noy2tics +set timestamp "" bottom norotate offset 0,0 +set rrange [ * : * ] noreverse nowriteback # (currently [-0:10] ) +set trange [ * : * ] noreverse nowriteback # (currently [-5:5] ) +set urange [ * : * ] noreverse nowriteback # (currently [-5:5] ) +set vrange [ * : * ] noreverse nowriteback # (currently [-5:5] ) +set xlabel "matrix size" offset 0,0 +set x2label "" offset 0,0 +set timefmt "%d/%m/%y\n%H:%M" +set xrange [ 10 : 1000 ] noreverse nowriteback +set x2range [ * : * ] noreverse nowriteback # (currently [-10:10] ) +set ylabel "MFLOPS" offset 0,0 +set y2label "" offset 0,0 +set yrange [ * : * ] noreverse nowriteback # (currently [-10:10] ) +set y2range [ * : * ] noreverse nowriteback # (currently [-10:10] ) +set zlabel "" offset 0,0 +set zrange [ * : * ] noreverse nowriteback # (currently [-10:10] ) +set zero 1e-08 +set lmargin -1 +set bmargin -1 +set rmargin -1 +set tmargin -1 +set locale "C" +set xrange [4:1024] + diff --git a/btl/data/go_mean b/btl/data/go_mean new file mode 100755 index 0000000..176c3c9 --- /dev/null +++ b/btl/data/go_mean @@ -0,0 +1,57 @@ +#!/bin/bash + +if [ $# < 1 ]; then + echo "Usage: $0 working_directory [tiny|large [prefix]]" +else + +mkdir -p $1 +##cp ../libs/*/*.dat $1 + +mode=large +if [ $# > 2 ]; then + mode=$2 +fi +if [ $# > 3 ]; then + prefix=$3 +fi + +EIGENDIR=`cat eigen_root_dir.txt` + +webpagefilename=$1/index.html +meanstatsfilename=$1/mean.html + +echo '' > $meanstatsfilename +echo '' > $webpagefilename +echo '<p><strong>Configuration</strong>' >> $webpagefilename +echo '<ul>'\ + '<li>' `cat /proc/cpuinfo | grep "model name" | head -n 1`\ + ' (' `uname -m` ')</li>'\ + '<li> compiler: ' `cat compiler_version.txt` '</li>'\ + '<li> eigen3: ' `hg identify -i $EIGENDIR` '</li>'\ + '</ul>' \ + '</p>' >> $webpagefilename + +source mk_mean_script.sh axpy $1 11 2500 100000 250000 $mode $prefix +source mk_mean_script.sh axpby $1 11 2500 100000 250000 $mode $prefix +source mk_mean_script.sh matrix_vector $1 11 50 300 1000 $mode $prefix +source mk_mean_script.sh atv $1 11 50 300 1000 $mode $prefix +source mk_mean_script.sh matrix_matrix $1 11 100 300 1000 $mode $prefix +source mk_mean_script.sh aat $1 11 100 300 1000 $mode $prefix +# source mk_mean_script.sh ata $1 11 100 300 1000 $mode $prefix +source mk_mean_script.sh trisolve_vector $1 11 100 300 1000 $mode $prefix +source mk_mean_script.sh trisolve_matrix $1 11 100 300 1000 $mode $prefix +source mk_mean_script.sh cholesky $1 11 100 300 1000 $mode $prefix +source mk_mean_script.sh partial_lu_decomp $1 11 100 300 1000 $mode $prefix +source mk_mean_script.sh tridiagonalization $1 11 100 300 1000 $mode $prefix +source mk_mean_script.sh hessenberg $1 11 100 300 1000 $mode $prefix +source mk_mean_script.sh symv $1 11 50 300 1000 $mode $prefix +source mk_mean_script.sh syr2 $1 11 50 300 1000 $mode $prefix +source mk_mean_script.sh ger $1 11 50 300 1000 $mode $prefix +source mk_mean_script.sh rot $1 11 2500 100000 250000 $mode $prefix +source mk_mean_script.sh complete_lu_decomp $1 11 100 300 1000 $mode $prefix + +fi + +## compile the web page ## + +#echo `cat footer.html` >> $webpagefilename
\ No newline at end of file diff --git a/btl/data/mean.cxx b/btl/data/mean.cxx new file mode 100644 index 0000000..c567ef3 --- /dev/null +++ b/btl/data/mean.cxx @@ -0,0 +1,182 @@ +//===================================================== +// File : mean.cxx +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, lun sep 30 14:23:15 CEST 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#include "utilities.h" +#include <vector> +#include <string> +#include <iostream> +#include <fstream> +#include "bench_parameter.hh" +#include "utils/xy_file.hh" +#include <set> + +using namespace std; + +double mean_calc(const vector<int> & tab_sizes, const vector<double> & tab_mflops, const int size_min, const int size_max); + +class Lib_Mean{ + +public: + Lib_Mean( void ):_lib_name(),_mean_in_cache(),_mean_out_of_cache(){ + MESSAGE("Lib_mean Default Ctor"); + MESSAGE("!!! should not be used"); + exit(0); + } + Lib_Mean(const string & name, const double & mic, const double & moc):_lib_name(name),_mean_in_cache(mic),_mean_out_of_cache(moc){ + MESSAGE("Lib_mean Ctor"); + } + Lib_Mean(const Lib_Mean & lm):_lib_name(lm._lib_name),_mean_in_cache(lm._mean_in_cache),_mean_out_of_cache(lm._mean_out_of_cache){ + MESSAGE("Lib_mean Copy Ctor"); + } + ~Lib_Mean( void ){ + MESSAGE("Lib_mean Dtor"); + } + + double _mean_in_cache; + double _mean_out_of_cache; + string _lib_name; + + bool operator < ( const Lib_Mean &right) const + { + //return ( this->_mean_out_of_cache > right._mean_out_of_cache) ; + return ( this->_mean_in_cache > right._mean_in_cache) ; + } + +}; + + +int main( int argc , char *argv[] ) +{ + + if (argc<6){ + INFOS("!!! Error ... usage : main what mic Mic moc Moc filename1 finename2..."); + exit(0); + } + INFOS(argc); + + int min_in_cache=atoi(argv[2]); + int max_in_cache=atoi(argv[3]); + int min_out_of_cache=atoi(argv[4]); + int max_out_of_cache=atoi(argv[5]); + + + multiset<Lib_Mean> s_lib_mean ; + + for (int i=6;i<argc;i++){ + + string filename=argv[i]; + + INFOS(filename); + + double mic=0; + double moc=0; + + { + + vector<int> tab_sizes; + vector<double> tab_mflops; + + read_xy_file(filename,tab_sizes,tab_mflops); + + mic=mean_calc(tab_sizes,tab_mflops,min_in_cache,max_in_cache); + moc=mean_calc(tab_sizes,tab_mflops,min_out_of_cache,max_out_of_cache); + + Lib_Mean cur_lib_mean(filename,mic,moc); + + s_lib_mean.insert(cur_lib_mean); + + } + + } + + + cout << "<TABLE BORDER CELLPADDING=2>" << endl ; + cout << " <TR>" << endl ; + cout << " <TH ALIGN=CENTER> " << argv[1] << " </TH>" << endl ; + cout << " <TH ALIGN=CENTER> <a href=""#mean_marker""> in cache <BR> mean perf <BR> Mflops </a></TH>" << endl ; + cout << " <TH ALIGN=CENTER> in cache <BR> % best </TH>" << endl ; + cout << " <TH ALIGN=CENTER> <a href=""#mean_marker""> out of cache <BR> mean perf <BR> Mflops </a></TH>" << endl ; + cout << " <TH ALIGN=CENTER> out of cache <BR> % best </TH>" << endl ; + cout << " <TH ALIGN=CENTER> details </TH>" << endl ; + cout << " <TH ALIGN=CENTER> comments </TH>" << endl ; + cout << " </TR>" << endl ; + + multiset<Lib_Mean>::iterator is = s_lib_mean.begin(); + Lib_Mean best(*is); + + + for (is=s_lib_mean.begin(); is!=s_lib_mean.end() ; is++){ + + cout << " <TR>" << endl ; + cout << " <TD> " << is->_lib_name << " </TD>" << endl ; + cout << " <TD> " << is->_mean_in_cache << " </TD>" << endl ; + cout << " <TD> " << 100*(is->_mean_in_cache/best._mean_in_cache) << " </TD>" << endl ; + cout << " <TD> " << is->_mean_out_of_cache << " </TD>" << endl ; + cout << " <TD> " << 100*(is->_mean_out_of_cache/best._mean_out_of_cache) << " </TD>" << endl ; + cout << " <TD> " << + "<a href=\"#"<<is->_lib_name<<"_"<<argv[1]<<"\">snippet</a>/" + "<a href=\"#"<<is->_lib_name<<"_flags\">flags</a> </TD>" << endl ; + cout << " <TD> " << + "<a href=\"#"<<is->_lib_name<<"_comments\">click here</a> </TD>" << endl ; + cout << " </TR>" << endl ; + + } + + cout << "</TABLE>" << endl ; + + ofstream output_file ("../order_lib",ios::out) ; + + for (is=s_lib_mean.begin(); is!=s_lib_mean.end() ; is++){ + output_file << is->_lib_name << endl ; + } + + output_file.close(); + +} + +double mean_calc(const vector<int> & tab_sizes, const vector<double> & tab_mflops, const int size_min, const int size_max){ + + int size=tab_sizes.size(); + int nb_sample=0; + double mean=0.0; + + for (int i=0;i<size;i++){ + + + if ((tab_sizes[i]>=size_min)&&(tab_sizes[i]<=size_max)){ + + nb_sample++; + mean+=tab_mflops[i]; + + } + + + } + + if (nb_sample==0){ + INFOS("no data for mean calculation"); + return 0.0; + } + + return mean/nb_sample; +} + + + + diff --git a/btl/data/mk_gnuplot_script.sh b/btl/data/mk_gnuplot_script.sh new file mode 100644 index 0000000..2ca7b5c --- /dev/null +++ b/btl/data/mk_gnuplot_script.sh @@ -0,0 +1,68 @@ +#! /bin/bash +WHAT=$1 +DIR=$2 +echo $WHAT script generation +cat $WHAT.hh > $WHAT.gnuplot + +DATA_FILE=`find $DIR -name "*.dat" | grep $WHAT` + +echo plot \\ >> $WHAT.gnuplot + +for FILE in $DATA_FILE +do + LAST=$FILE +done + +echo LAST=$LAST + +for FILE in $DATA_FILE +do + if [ $FILE != $LAST ] + then + BASE=${FILE##*/} ; BASE=${FILE##*/} ; AVANT=bench_${WHAT}_ ; REDUC=${BASE##*$AVANT} ; TITLE=${REDUC%.dat} + echo "'"$FILE"'" title "'"$TITLE"'" ",\\" >> $WHAT.gnuplot + fi +done +BASE=${LAST##*/} ; BASE=${FILE##*/} ; AVANT=bench_${WHAT}_ ; REDUC=${BASE##*$AVANT} ; TITLE=${REDUC%.dat} +echo "'"$LAST"'" title "'"$TITLE"'" >> $WHAT.gnuplot + +#echo set term postscript color >> $WHAT.gnuplot +#echo set output "'"$WHAT.ps"'" >> $WHAT.gnuplot +echo set term pbm small color >> $WHAT.gnuplot +echo set output "'"$WHAT.ppm"'" >> $WHAT.gnuplot +echo plot \\ >> $WHAT.gnuplot + +for FILE in $DATA_FILE +do + if [ $FILE != $LAST ] + then + BASE=${FILE##*/} ; BASE=${FILE##*/} ; AVANT=bench_${WHAT}_ ; REDUC=${BASE##*$AVANT} ; TITLE=${REDUC%.dat} + echo "'"$FILE"'" title "'"$TITLE"'" ",\\" >> $WHAT.gnuplot + fi +done +BASE=${LAST##*/} ; BASE=${FILE##*/} ; AVANT=bench_${WHAT}_ ; REDUC=${BASE##*$AVANT} ; TITLE=${REDUC%.dat} +echo "'"$LAST"'" title "'"$TITLE"'" >> $WHAT.gnuplot + +echo set term jpeg large >> $WHAT.gnuplot +echo set output "'"$WHAT.jpg"'" >> $WHAT.gnuplot +echo plot \\ >> $WHAT.gnuplot + +for FILE in $DATA_FILE +do + if [ $FILE != $LAST ] + then + BASE=${FILE##*/} ; BASE=${FILE##*/} ; AVANT=bench_${WHAT}_ ; REDUC=${BASE##*$AVANT} ; TITLE=${REDUC%.dat} + echo "'"$FILE"'" title "'"$TITLE"'" ",\\" >> $WHAT.gnuplot + fi +done +BASE=${LAST##*/} ; BASE=${FILE##*/} ; AVANT=bench_${WHAT}_ ; REDUC=${BASE##*$AVANT} ; TITLE=${REDUC%.dat} +echo "'"$LAST"'" title "'"$TITLE"'" >> $WHAT.gnuplot + + +gnuplot -persist < $WHAT.gnuplot + +rm $WHAT.gnuplot + + + + diff --git a/btl/data/mk_mean_script.sh b/btl/data/mk_mean_script.sh new file mode 100644 index 0000000..b10df02 --- /dev/null +++ b/btl/data/mk_mean_script.sh @@ -0,0 +1,52 @@ +#! /bin/bash +WHAT=$1 +DIR=$2 +MINIC=$3 +MAXIC=$4 +MINOC=$5 +MAXOC=$6 +prefix=$8 + +meanstatsfilename=$2/mean.html + +WORK_DIR=tmp +mkdir $WORK_DIR + +DATA_FILE=`find $DIR -name "*.dat" | grep _${WHAT}` + +if [ -n "$DATA_FILE" ]; then + + echo "" + echo "$1..." + for FILE in $DATA_FILE + do + ##echo hello world + ##echo "mk_mean_script1" ${FILE} + BASE=${FILE##*/} ; BASE=${FILE##*/} ; AVANT=bench_${WHAT}_ ; REDUC=${BASE##*$AVANT} ; TITLE=${REDUC%.dat} + + ##echo "mk_mean_script1" ${TITLE} + cp $FILE ${WORK_DIR}/${TITLE} + + done + + cd $WORK_DIR + ../main $1 $3 $4 $5 $6 * >> ../$meanstatsfilename + ../mk_new_gnuplot.sh $1 $2 $7 + rm -f *.gnuplot + cd .. + + echo '<br/>' >> $meanstatsfilename + + webpagefilename=$2/index.html + # echo '<h3>'${WHAT}'</h3>' >> $webpagefilename + echo '<hr/><a href="'$prefix$1'.pdf"><img src="'$prefix$1'.png" alt="'${WHAT}'" /></a><br/>' >> $webpagefilename + +fi + +rm -R $WORK_DIR + + + + + + diff --git a/btl/data/mk_new_gnuplot.sh b/btl/data/mk_new_gnuplot.sh new file mode 100755 index 0000000..fad3b23 --- /dev/null +++ b/btl/data/mk_new_gnuplot.sh @@ -0,0 +1,54 @@ +#!/bin/bash +WHAT=$1 +DIR=$2 + +cat ../gnuplot_common_settings.hh > ${WHAT}.gnuplot + +echo "set title " `grep ${WHAT} ../action_settings.txt | head -n 1 | cut -d ";" -f 2` >> $WHAT.gnuplot +echo "set xlabel " `grep ${WHAT} ../action_settings.txt | head -n 1 | cut -d ";" -f 3` " offset 0,0" >> $WHAT.gnuplot +echo "set xrange [" `grep ${WHAT} ../action_settings.txt | head -n 1 | cut -d ";" -f 4` "]" >> $WHAT.gnuplot + +if [ $# > 3 ]; then + if [ "$3" == "tiny" ]; then + echo "set xrange [2:16]" >> $WHAT.gnuplot + echo "set nologscale" >> $WHAT.gnuplot + fi +fi + + + +DATA_FILE=`cat ../order_lib` +echo set term postscript color rounded enhanced >> $WHAT.gnuplot +echo set output "'"../${DIR}/$WHAT.ps"'" >> $WHAT.gnuplot + +# echo set term svg color rounded enhanced >> $WHAT.gnuplot +# echo "set terminal svg enhanced size 1000 1000 fname \"Times\" fsize 36" >> $WHAT.gnuplot +# echo set output "'"../${DIR}/$WHAT.svg"'" >> $WHAT.gnuplot + +echo plot \\ >> $WHAT.gnuplot + +for FILE in $DATA_FILE +do + LAST=$FILE +done + +for FILE in $DATA_FILE +do + BASE=${FILE##*/} ; BASE=${FILE##*/} ; AVANT=bench_${WHAT}_ ; REDUC=${BASE##*$AVANT} ; TITLE=${REDUC%.dat} + + echo "'"$FILE"'" `grep $TITLE ../perlib_plot_settings.txt | head -n 1 | cut -d ";" -f 2` "\\" >> $WHAT.gnuplot + if [ $FILE != $LAST ] + then + echo ", \\" >> $WHAT.gnuplot + fi +done +echo " " >> $WHAT.gnuplot + +gnuplot -persist < $WHAT.gnuplot + +rm $WHAT.gnuplot + +ps2pdf ../${DIR}/$WHAT.ps ../${DIR}/$WHAT.pdf +convert -background white -density 120 -rotate 90 -resize 800 +dither -colors 256 -quality 0 ../${DIR}/$WHAT.ps -background white -flatten ../${DIR}/$WHAT.png + +# pstoedit -rotate -90 -xscale 0.8 -yscale 0.8 -centered -yshift -50 -xshift -100 -f plot-svg aat.ps aat2.svg diff --git a/btl/data/perlib_plot_settings.txt b/btl/data/perlib_plot_settings.txt new file mode 100644 index 0000000..6844bab --- /dev/null +++ b/btl/data/perlib_plot_settings.txt @@ -0,0 +1,16 @@ +eigen3 ; with lines lw 4 lt 1 lc rgbcolor "black" +eigen2 ; with lines lw 3 lt 1 lc rgbcolor "#999999" +EigenBLAS ; with lines lw 3 lt 3 lc rgbcolor "#999999" +eigen3_novec ; with lines lw 2 lt 1 lc rgbcolor "#999999" +eigen3_nogccvec ; with lines lw 2 lt 2 lc rgbcolor "#991010" +INTEL_MKL ; with lines lw 3 lt 1 lc rgbcolor "#ff0000" +ATLAS ; with lines lw 3 lt 1 lc rgbcolor "#008000" +gmm ; with lines lw 3 lt 1 lc rgbcolor "#0000ff" +ublas ; with lines lw 3 lt 1 lc rgbcolor "#00b7ff" +mtl4 ; with lines lw 3 lt 1 lc rgbcolor "#d18847" +blitz ; with lines lw 3 lt 1 lc rgbcolor "#ff00ff" +F77 ; with lines lw 3 lt 3 lc rgbcolor "#e6e64c" +GOTO ; with lines lw 3 lt 3 lc rgbcolor "#C05600" +GOTO2 ; with lines lw 3 lt 1 lc rgbcolor "#C05600" +C ; with lines lw 3 lt 3 lc rgbcolor "#e6bd96" +ACML ; with lines lw 2 lt 3 lc rgbcolor "#e6e64c" diff --git a/btl/data/regularize.cxx b/btl/data/regularize.cxx new file mode 100644 index 0000000..eea2b8b --- /dev/null +++ b/btl/data/regularize.cxx @@ -0,0 +1,131 @@ +//===================================================== +// File : regularize.cxx +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, lun sep 30 14:23:15 CEST 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#include "utilities.h" +#include <vector> +#include <string> +#include <iostream> +#include <fstream> +#include "bench_parameter.hh" +#include <set> + +using namespace std; + +void read_xy_file(const string & filename, vector<int> & tab_sizes, vector<double> & tab_mflops); +void regularize_curve(const string & filename, + const vector<double> & tab_mflops, + const vector<int> & tab_sizes, + int start_cut_size, int stop_cut_size); +///////////////////////////////////////////////////////////////////////////////////////////////// + +int main( int argc , char *argv[] ) +{ + + // input data + + if (argc<4){ + INFOS("!!! Error ... usage : main filename start_cut_size stop_cut_size regularize_filename"); + exit(0); + } + INFOS(argc); + + int start_cut_size=atoi(argv[2]); + int stop_cut_size=atoi(argv[3]); + + string filename=argv[1]; + string regularize_filename=argv[4]; + + INFOS(filename); + INFOS("start_cut_size="<<start_cut_size); + + vector<int> tab_sizes; + vector<double> tab_mflops; + + read_xy_file(filename,tab_sizes,tab_mflops); + + // regularizeing + + regularize_curve(regularize_filename,tab_mflops,tab_sizes,start_cut_size,stop_cut_size); + + +} + +////////////////////////////////////////////////////////////////////////////////////// + +void regularize_curve(const string & filename, + const vector<double> & tab_mflops, + const vector<int> & tab_sizes, + int start_cut_size, int stop_cut_size) +{ + int size=tab_mflops.size(); + ofstream output_file (filename.c_str(),ios::out) ; + + int i=0; + + while(tab_sizes[i]<start_cut_size){ + + output_file << tab_sizes[i] << " " << tab_mflops[i] << endl ; + i++; + + } + + output_file << endl ; + + while(tab_sizes[i]<stop_cut_size){ + + i++; + + } + + while(i<size){ + + output_file << tab_sizes[i] << " " << tab_mflops[i] << endl ; + i++; + + } + + output_file.close(); + +} + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +void read_xy_file(const string & filename, vector<int> & tab_sizes, vector<double> & tab_mflops){ + + ifstream input_file (filename.c_str(),ios::in) ; + + if (!input_file){ + INFOS("!!! Error opening "<<filename); + exit(0); + } + + int nb_point=0; + int size=0; + double mflops=0; + + while (input_file >> size >> mflops ){ + nb_point++; + tab_sizes.push_back(size); + tab_mflops.push_back(mflops); + } + SCRUTE(nb_point); + + input_file.close(); +} + diff --git a/btl/data/smooth.cxx b/btl/data/smooth.cxx new file mode 100644 index 0000000..e5270cc --- /dev/null +++ b/btl/data/smooth.cxx @@ -0,0 +1,198 @@ +//===================================================== +// File : smooth.cxx +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, lun sep 30 14:23:15 CEST 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#include "utilities.h" +#include <vector> +#include <deque> +#include <string> +#include <iostream> +#include <fstream> +#include "bench_parameter.hh" +#include <set> + +using namespace std; + +void read_xy_file(const string & filename, vector<int> & tab_sizes, vector<double> & tab_mflops); +void write_xy_file(const string & filename, vector<int> & tab_sizes, vector<double> & tab_mflops); +void smooth_curve(const vector<double> & tab_mflops, vector<double> & smooth_tab_mflops,int window_half_width); +void centered_smooth_curve(const vector<double> & tab_mflops, vector<double> & smooth_tab_mflops,int window_half_width); + +///////////////////////////////////////////////////////////////////////////////////////////////// + +int main( int argc , char *argv[] ) +{ + + // input data + + if (argc<3){ + INFOS("!!! Error ... usage : main filename window_half_width smooth_filename"); + exit(0); + } + INFOS(argc); + + int window_half_width=atoi(argv[2]); + + string filename=argv[1]; + string smooth_filename=argv[3]; + + INFOS(filename); + INFOS("window_half_width="<<window_half_width); + + vector<int> tab_sizes; + vector<double> tab_mflops; + + read_xy_file(filename,tab_sizes,tab_mflops); + + // smoothing + + vector<double> smooth_tab_mflops; + + //smooth_curve(tab_mflops,smooth_tab_mflops,window_half_width); + centered_smooth_curve(tab_mflops,smooth_tab_mflops,window_half_width); + + // output result + + write_xy_file(smooth_filename,tab_sizes,smooth_tab_mflops); + + +} + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +template<class VECTOR> +double weighted_mean(const VECTOR & data) +{ + + double mean=0.0; + + for (int i=0 ; i<data.size() ; i++){ + + mean+=data[i]; + + } + + return mean/double(data.size()) ; + +} + + + + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + +void smooth_curve(const vector<double> & tab_mflops, vector<double> & smooth_tab_mflops,int window_half_width){ + + int window_width=2*window_half_width+1; + + int size=tab_mflops.size(); + + vector<double> sample(window_width); + + for (int i=0 ; i < size ; i++){ + + for ( int j=0 ; j < window_width ; j++ ){ + + int shifted_index=i+j-window_half_width; + if (shifted_index<0) shifted_index=0; + if (shifted_index>size-1) shifted_index=size-1; + sample[j]=tab_mflops[shifted_index]; + + } + + smooth_tab_mflops.push_back(weighted_mean(sample)); + + } + +} + +void centered_smooth_curve(const vector<double> & tab_mflops, vector<double> & smooth_tab_mflops,int window_half_width){ + + int max_window_width=2*window_half_width+1; + + int size=tab_mflops.size(); + + + for (int i=0 ; i < size ; i++){ + + deque<double> sample; + + + sample.push_back(tab_mflops[i]); + + for ( int j=1 ; j <= window_half_width ; j++ ){ + + int before=i-j; + int after=i+j; + + if ((before>=0)&&(after<size)) // inside of the vector + { + sample.push_front(tab_mflops[before]); + sample.push_back(tab_mflops[after]); + } + } + + smooth_tab_mflops.push_back(weighted_mean(sample)); + + } + +} + + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +void write_xy_file(const string & filename, vector<int> & tab_sizes, vector<double> & tab_mflops){ + + ofstream output_file (filename.c_str(),ios::out) ; + + for (int i=0 ; i < tab_sizes.size() ; i++) + { + output_file << tab_sizes[i] << " " << tab_mflops[i] << endl ; + } + + output_file.close(); + +} + + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +void read_xy_file(const string & filename, vector<int> & tab_sizes, vector<double> & tab_mflops){ + + ifstream input_file (filename.c_str(),ios::in) ; + + if (!input_file){ + INFOS("!!! Error opening "<<filename); + exit(0); + } + + int nb_point=0; + int size=0; + double mflops=0; + + while (input_file >> size >> mflops ){ + nb_point++; + tab_sizes.push_back(size); + tab_mflops.push_back(mflops); + } + SCRUTE(nb_point); + + input_file.close(); +} + diff --git a/btl/data/smooth_all.sh b/btl/data/smooth_all.sh new file mode 100755 index 0000000..3e5bfdf --- /dev/null +++ b/btl/data/smooth_all.sh @@ -0,0 +1,68 @@ +#! /bin/bash +ORIG_DIR=$1 +SMOOTH_DIR=${ORIG_DIR}_smooth +mkdir ${SMOOTH_DIR} + +AXPY_FILE=`find ${ORIG_DIR} -name "*.dat" | grep axpy` +for FILE in ${AXPY_FILE} +do + echo $FILE + BASE=${FILE##*/} + ./smooth ${ORIG_DIR}/${BASE} 4 ${SMOOTH_DIR}/${BASE}_tmp + ./regularize ${SMOOTH_DIR}/${BASE}_tmp 2500 15000 ${SMOOTH_DIR}/${BASE} + rm -f ${SMOOTH_DIR}/${BASE}_tmp +done + + +MATRIX_VECTOR_FILE=`find ${ORIG_DIR} -name "*.dat" | grep matrix_vector` +for FILE in ${MATRIX_VECTOR_FILE} +do + echo $FILE + BASE=${FILE##*/} + ./smooth ${ORIG_DIR}/${BASE} 4 ${SMOOTH_DIR}/${BASE}_tmp + ./regularize ${SMOOTH_DIR}/${BASE}_tmp 50 180 ${SMOOTH_DIR}/${BASE} + rm -f ${SMOOTH_DIR}/${BASE}_tmp +done + +MATRIX_MATRIX_FILE=`find ${ORIG_DIR} -name "*.dat" | grep matrix_matrix` +for FILE in ${MATRIX_MATRIX_FILE} +do + echo $FILE + BASE=${FILE##*/} + ./smooth ${ORIG_DIR}/${BASE} 4 ${SMOOTH_DIR}/${BASE} +done + +AAT_FILE=`find ${ORIG_DIR} -name "*.dat" | grep _aat` +for FILE in ${AAT_FILE} +do + echo $FILE + BASE=${FILE##*/} + ./smooth ${ORIG_DIR}/${BASE} 4 ${SMOOTH_DIR}/${BASE} +done + + +ATA_FILE=`find ${ORIG_DIR} -name "*.dat" | grep _ata` +for FILE in ${ATA_FILE} +do + echo $FILE + BASE=${FILE##*/} + ./smooth ${ORIG_DIR}/${BASE} 4 ${SMOOTH_DIR}/${BASE} +done + +### no smoothing for tinyvector and matrices libs + +TINY_BLITZ_FILE=`find ${ORIG_DIR} -name "*.dat" | grep tiny_blitz` +for FILE in ${TINY_BLITZ_FILE} +do + echo $FILE + BASE=${FILE##*/} + cp ${ORIG_DIR}/${BASE} ${SMOOTH_DIR}/${BASE} +done + +TVMET_FILE=`find ${ORIG_DIR} -name "*.dat" | grep tvmet` +for FILE in ${TVMET_FILE} +do + echo $FILE + BASE=${FILE##*/} + cp ${ORIG_DIR}/${BASE} ${SMOOTH_DIR}/${BASE} +done diff --git a/btl/generic_bench/bench.hh b/btl/generic_bench/bench.hh new file mode 100644 index 0000000..4004797 --- /dev/null +++ b/btl/generic_bench/bench.hh @@ -0,0 +1,103 @@ +//===================================================== +// File : bench.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, lun sep 30 14:23:16 CEST 2002 +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef BENCH_HH +#define BENCH_HH + +#include "btl.hh" +#include "bench_parameter.hh" +#include <iostream> +#include "utilities.h" +#include "size_lin_log.hh" +#include "xy_file.hh" +#include <vector> +#include <string> +#include "timers/portable_perf_analyzer.hh" + +#ifdef DISTRIBUTED +#include "timers/distributed_perf_analyzer_root.hh" +#include "timers/distributed_perf_analyzer_node.hh" +#endif + +// #include "timers/mixed_perf_analyzer.hh" +// #include "timers/x86_perf_analyzer.hh" +// #include "timers/STL_perf_analyzer.hh" +#ifdef HAVE_MKL +extern "C" void cblas_saxpy(const int, const float, const float*, const int, float *, const int); +#endif + +template <template<class> class Perf_Analyzer, class Action> +BTL_DONT_INLINE void bench( int size_min, int size_max, int nb_point, bool silent = false ) +{ + std::string filename = "bench_"+Action::name()+".dat"; + + if (!silent) { INFOS("starting " <<filename); } + + // utilities + + std::vector<double> tab_mflops(nb_point); + std::vector<int> tab_sizes(nb_point); + + // matrices and vector size calculations + size_lin_log(nb_point,size_min,size_max,tab_sizes); + + // loop on matrix size + Perf_Analyzer<Action> perf_action; + for (int i=nb_point-1; i>=0; i--) + { + if (!silent) + std::cout << " " << "size = " << tab_sizes[i] << " " << std::flush; + + BTL_DISABLE_SSE_EXCEPTIONS(); + + tab_mflops[i] = perf_action.eval_mflops(tab_sizes[i], silent); + if (!silent) + std::cout << tab_mflops[i] << " MFlops (" << nb_point-i << "/" << nb_point << ")" << std::endl; + } + + // dump the result in a file : + if (!silent) dump_xy_file(tab_sizes, tab_mflops, filename); + +} + +// default Perf Analyzer + +template <class Action> +BTL_DONT_INLINE void bench( int size_min, int size_max, int nb_point, bool silent = false) +{ + bench<Portable_Perf_Analyzer,Action>(size_min,size_max,nb_point,silent); +} + +#ifdef DISTRIBUTED +// distributed Perf Analyzer + +template <class Action> +BTL_DONT_INLINE void distr_bench( int size_min, int size_max, int nb_point, bool silent = false) +{ + int myid, nproc; + blacs_pinfo_(&myid, &nproc); + if (myid) + bench<Distributed_Perf_Analyzer_Node, Action>(size_min, size_max, nb_point, silent); + else + bench<Distributed_Perf_Analyzer_Root, Action>(size_min, size_max, nb_point, silent); +} +#endif + +#endif diff --git a/btl/generic_bench/bench_parameter.hh b/btl/generic_bench/bench_parameter.hh new file mode 100644 index 0000000..4c355cd --- /dev/null +++ b/btl/generic_bench/bench_parameter.hh @@ -0,0 +1,53 @@ +//===================================================== +// File : bench_parameter.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, lun sep 30 14:23:16 CEST 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef BENCH_PARAMETER_HH +#define BENCH_PARAMETER_HH + +// minimal time for each measurement +#define REAL_TYPE float +// minimal time for each measurement +#define MIN_TIME 0.2 +// nb of point on bench curves +#define NB_POINT 100 +// min vector size for axpy bench +#define MIN_AXPY 5 +// max vector size for axpy bench +#define MAX_AXPY 1000000 +// min matrix size for matrix vector product bench +#define MIN_MV 5 +// max matrix size for matrix vector product bench +#define MAX_MV 3000 +// min matrix size for matrix matrix product bench +#define MIN_MM 5 +// max matrix size for matrix matrix product bench +#define MAX_MM MAX_MV +// min matrix size for LU bench +#define MIN_LU 5 +// max matrix size for LU bench +#define MAX_LU 3000 +// max size for tiny vector and matrix +#define TINY_MV_MAX_SIZE 16 +// default nb_sample for x86 timer +#define DEFAULT_NB_SAMPLE 1000 + +// how many times we run a single bench (keep the best perf) +#define DEFAULT_NB_TRIES 3 + +#endif diff --git a/btl/generic_bench/btl.hh b/btl/generic_bench/btl.hh new file mode 100644 index 0000000..17cd397 --- /dev/null +++ b/btl/generic_bench/btl.hh @@ -0,0 +1,247 @@ +//===================================================== +// File : btl.hh +// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef BTL_HH +#define BTL_HH + +#include "bench_parameter.hh" +#include <iostream> +#include <algorithm> +#include <vector> +#include <string> +#include "utilities.h" + +#if (defined __GNUC__) +#define BTL_ALWAYS_INLINE __attribute__((always_inline)) inline +#else +#define BTL_ALWAYS_INLINE inline +#endif + +#if (defined __GNUC__) +#define BTL_DONT_INLINE __attribute__((noinline)) +#else +#define BTL_DONT_INLINE +#endif + +#if (defined __GNUC__) +#define BTL_ASM_COMMENT(X) asm("#"X) +#else +#define BTL_ASM_COMMENT(X) +#endif + +#if (defined __GNUC__) && (!defined __INTEL_COMPILER) && !defined(__arm__) && !defined(__powerpc__) +#define BTL_DISABLE_SSE_EXCEPTIONS() { \ + int aux; \ + asm( \ + "stmxcsr %[aux] \n\t" \ + "orl $32832, %[aux] \n\t" \ + "ldmxcsr %[aux] \n\t" \ + : : [aux] "m" (aux)); \ +} +#else +#define BTL_DISABLE_SSE_EXCEPTIONS() +#endif + +/** Enhanced std::string +*/ +class BtlString : public std::string +{ +public: + BtlString() : std::string() {} + BtlString(const BtlString& str) : std::string(static_cast<const std::string&>(str)) {} + BtlString(const std::string& str) : std::string(str) {} + BtlString(const char* str) : std::string(str) {} + + operator const char* () const { return c_str(); } + + void trim( bool left = true, bool right = true ) + { + int lspaces, rspaces, len = length(), i; + lspaces = rspaces = 0; + + if ( left ) + for (i=0; i<len && (at(i)==' '||at(i)=='\t'||at(i)=='\r'||at(i)=='\n'); ++lspaces,++i); + + if ( right && lspaces < len ) + for(i=len-1; i>=0 && (at(i)==' '||at(i)=='\t'||at(i)=='\r'||at(i)=='\n'); rspaces++,i--); + + *this = substr(lspaces, len-lspaces-rspaces); + } + + std::vector<BtlString> split( const BtlString& delims = "\t\n ") const + { + std::vector<BtlString> ret; + unsigned int numSplits = 0; + size_t start, pos; + start = 0; + do + { + pos = find_first_of(delims, start); + if (pos == start) + { + ret.push_back(""); + start = pos + 1; + } + else if (pos == npos) + ret.push_back( substr(start) ); + else + { + ret.push_back( substr(start, pos - start) ); + start = pos + 1; + } + //start = find_first_not_of(delims, start); + ++numSplits; + } while (pos != npos); + return ret; + } + + bool endsWith(const BtlString& str) const + { + if(str.size()>this->size()) + return false; + return this->substr(this->size()-str.size(),str.size()) == str; + } + bool contains(const BtlString& str) const + { + return this->find(str)<this->size(); + } + bool beginsWith(const BtlString& str) const + { + if(str.size()>this->size()) + return false; + return this->substr(0,str.size()) == str; + } + + BtlString toLowerCase( void ) + { + std::transform(begin(), end(), begin(), static_cast<int(*)(int)>(::tolower) ); + return *this; + } + BtlString toUpperCase( void ) + { + std::transform(begin(), end(), begin(), static_cast<int(*)(int)>(::toupper) ); + return *this; + } + + /** Case insensitive comparison. + */ + bool isEquiv(const BtlString& str) const + { + BtlString str0 = *this; + str0.toLowerCase(); + BtlString str1 = str; + str1.toLowerCase(); + return str0 == str1; + } + + /** Decompose the current string as a path and a file. + For instance: "dir1/dir2/file.ext" leads to path="dir1/dir2/" and filename="file.ext" + */ + void decomposePathAndFile(BtlString& path, BtlString& filename) const + { + std::vector<BtlString> elements = this->split("/\\"); + path = ""; + filename = elements.back(); + elements.pop_back(); + if (this->at(0)=='/') + path = "/"; + for (unsigned int i=0 ; i<elements.size() ; ++i) + path += elements[i] + "/"; + } +}; + +class BtlConfig +{ +public: + BtlConfig() + : overwriteResults(false), checkResults(true), realclock(false), tries(DEFAULT_NB_TRIES) + { + char * _config; + _config = getenv ("BTL_CONFIG"); + if (_config!=NULL) + { + std::vector<BtlString> config = BtlString(_config).split(" \t\n"); + for (int i = 0; i<config.size(); i++) + { + if (config[i].beginsWith("-a")) + { + if (i+1==config.size()) + { + std::cerr << "error processing option: " << config[i] << "\n"; + exit(2); + } + Instance.m_selectedActionNames = config[i+1].split(":"); + + i += 1; + } + else if (config[i].beginsWith("-t")) + { + if (i+1==config.size()) + { + std::cerr << "error processing option: " << config[i] << "\n"; + exit(2); + } + Instance.tries = atoi(config[i+1].c_str()); + + i += 1; + } + else if (config[i].beginsWith("--overwrite")) + { + Instance.overwriteResults = true; + } + else if (config[i].beginsWith("--nocheck")) + { + Instance.checkResults = false; + } + else if (config[i].beginsWith("--real")) + { + Instance.realclock = true; + } + } + } + + BTL_DISABLE_SSE_EXCEPTIONS(); + } + + BTL_DONT_INLINE static bool skipAction(const std::string& _name) + { + if (Instance.m_selectedActionNames.empty()) + return false; + + BtlString name(_name); + for (int i=0; i<Instance.m_selectedActionNames.size(); ++i) + if (name.contains(Instance.m_selectedActionNames[i])) + return false; + + return true; + } + + static BtlConfig Instance; + bool overwriteResults; + bool checkResults; + bool realclock; + int tries; + +protected: + std::vector<BtlString> m_selectedActionNames; +}; + +#define BTL_MAIN \ + BtlConfig BtlConfig::Instance + +#endif // BTL_HH diff --git a/btl/generic_bench/init/init_function.hh b/btl/generic_bench/init/init_function.hh new file mode 100644 index 0000000..7b3bdba --- /dev/null +++ b/btl/generic_bench/init/init_function.hh @@ -0,0 +1,54 @@ +//===================================================== +// File : init_function.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, lun sep 30 14:23:18 CEST 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef INIT_FUNCTION_HH +#define INIT_FUNCTION_HH + +double simple_function(int index) +{ + return index; +} + +double simple_function(int index_i, int index_j) +{ + return index_i+index_j; +} + +double pseudo_random(int index) +{ + return std::rand()/double(RAND_MAX); +} + +double pseudo_random(int index_i, int index_j) +{ + return std::rand()/double(RAND_MAX); +} + + +double null_function(int index) +{ + return 0.0; +} + +double null_function(int index_i, int index_j) +{ + return 0.0; +} + +#endif diff --git a/btl/generic_bench/init/init_matrix.hh b/btl/generic_bench/init/init_matrix.hh new file mode 100644 index 0000000..c598ffc --- /dev/null +++ b/btl/generic_bench/init/init_matrix.hh @@ -0,0 +1,93 @@ +//===================================================== +// File : init_matrix.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, lun sep 30 14:23:19 CEST 2002 +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef INIT_MATRIX_HH +#define INIT_MATRIX_HH + +#include "LinearCongruential.hh" + +// The Vector class must satisfy the following part of STL vector concept : +// resize() method +// [] operator for setting element +// value_type defined +template<double init_function(int,int), class Vector> +BTL_DONT_INLINE void init_row(Vector & X, int size, int row){ + + X.resize(size); + + for (int j=0;j<X.size();j++){ + X[j]=typename Vector::value_type(init_function(row,j)); + } +} + + +// Matrix is a Vector of Vector +// The Matrix class must satisfy the following part of STL vector concept : +// resize() method +// [] operator for setting rows +template<double init_function(int,int),class Vector> +BTL_DONT_INLINE void init_matrix(Vector & A, int size){ + A.resize(size); + for (int row=0; row<A.size() ; row++){ + init_row<init_function>(A[row],size,row); + } +} + +template<double init_function(int,int),class Matrix> +BTL_DONT_INLINE void init_matrix_symm(Matrix& A, int size){ + A.resize(size); + for (int row=0; row<A.size() ; row++) + A[row].resize(size); + for (int row=0; row<A.size() ; row++){ + A[row][row] = init_function(row,row); + for (int col=0; col<row ; col++){ + double x = init_function(row,col); + A[row][col] = A[col][row] = x; + } + } +} + +template<class Matrix> BTL_DONT_INLINE +void init_matrix(Matrix& A, const int& size, const unsigned& seed) +{ + typedef typename Matrix::value_type value_t; + A.resize(size*size); + LinearCongruential rng(seed); + for (typename Matrix::iterator i = A.begin(), end = A.end(); i != end; ++i) + *i = rng.get_01(); +} + +template<class Matrix> BTL_DONT_INLINE +void init_SPD_matrix(Matrix& A, const int& size, const unsigned& seed) +{ + typedef typename Matrix::value_type value_t; + A.resize(size*size); + LinearCongruential rng(seed); + for (int r = 0; r < size; ++r) { + A[r+size*r] = rng.get_01() + size; + for (int c = r+1; c < size; ++c) { + const value_t v = rng.get_01(); + A[r+size*c] = v; + A[c+size*r] = v; + } + } +} + +#endif diff --git a/btl/generic_bench/init/init_vector.hh b/btl/generic_bench/init/init_vector.hh new file mode 100644 index 0000000..efaf0c9 --- /dev/null +++ b/btl/generic_bench/init/init_vector.hh @@ -0,0 +1,37 @@ +//===================================================== +// File : init_vector.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, lun sep 30 14:23:18 CEST 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef INIT_VECTOR_HH +#define INIT_VECTOR_HH + +// The Vector class must satisfy the following part of STL vector concept : +// resize() method +// [] operator for setting element +// value_type defined +template<double init_function(int), class Vector> +void init_vector(Vector & X, int size){ + + X.resize(size); + + for (int i=0;i<X.size();i++){ + X[i]=typename Vector::value_type(init_function(i)); + } +} + +#endif diff --git a/btl/generic_bench/static/bench_static.hh b/btl/generic_bench/static/bench_static.hh new file mode 100644 index 0000000..23b55ec --- /dev/null +++ b/btl/generic_bench/static/bench_static.hh @@ -0,0 +1,80 @@ +//===================================================== +// File : bench_static.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, lun sep 30 14:23:16 CEST 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef BENCH_STATIC_HH +#define BENCH_STATIC_HH + +#include "btl.hh" +#include "bench_parameter.hh" +#include <iostream> +#include "utilities.h" +#include "xy_file.hh" +#include "static/static_size_generator.hh" +#include "timers/portable_perf_analyzer.hh" +// #include "timers/mixed_perf_analyzer.hh" +// #include "timers/x86_perf_analyzer.hh" + +using namespace std; + + +template <template<class> class Perf_Analyzer, template<class> class Action, template<class,int> class Interface> +BTL_DONT_INLINE void bench_static(void) +{ + if (BtlConfig::skipAction(Action<Interface<REAL_TYPE,10> >::name())) + return; + + string filename = "bench_" + Action<Interface<REAL_TYPE,10> >::name() + ".dat"; + + INFOS("starting " << filename); + + const int max_size = TINY_MV_MAX_SIZE; + + std::vector<double> tab_mflops; + std::vector<double> tab_sizes; + + static_size_generator<max_size,Perf_Analyzer,Action,Interface>::go(tab_sizes,tab_mflops); + + dump_xy_file(tab_sizes,tab_mflops,filename); +} + +// default Perf Analyzer +template <template<class> class Action, template<class,int> class Interface> +BTL_DONT_INLINE void bench_static(void) +{ + bench_static<Portable_Perf_Analyzer,Action,Interface>(); + //bench_static<Mixed_Perf_Analyzer,Action,Interface>(); + //bench_static<X86_Perf_Analyzer,Action,Interface>(); +} + +#endif + + + + + + + + + + + + + + + diff --git a/btl/generic_bench/static/intel_bench_fixed_size.hh b/btl/generic_bench/static/intel_bench_fixed_size.hh new file mode 100644 index 0000000..b4edcbc --- /dev/null +++ b/btl/generic_bench/static/intel_bench_fixed_size.hh @@ -0,0 +1,66 @@ +//===================================================== +// File : intel_bench_fixed_size.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, mar déc 3 18:59:37 CET 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef _BENCH_FIXED_SIZE_HH_ +#define _BENCH_FIXED_SIZE_HH_ + +#include "utilities.h" +#include "function_time.hh" + +template <class Action> +double bench_fixed_size(int size, unsigned long long & nb_calc,unsigned long long & nb_init) +{ + + Action action(size); + + double time_baseline=time_init(nb_init,action); + + while (time_baseline < MIN_TIME) { + + //INFOS("nb_init="<<nb_init); + //INFOS("time_baseline="<<time_baseline); + nb_init*=2; + time_baseline=time_init(nb_init,action); + } + + time_baseline=time_baseline/(double(nb_init)); + + double time_action=time_calculate(nb_calc,action); + + while (time_action < MIN_TIME) { + + nb_calc*=2; + time_action=time_calculate(nb_calc,action); + } + + INFOS("nb_init="<<nb_init); + INFOS("nb_calc="<<nb_calc); + + + time_action=time_action/(double(nb_calc)); + + action.check_result(); + + time_action=time_action-time_baseline; + + return action.nb_op_base()/(time_action*1000000.0); + +} + +#endif diff --git a/btl/generic_bench/static/static_size_generator.hh b/btl/generic_bench/static/static_size_generator.hh new file mode 100644 index 0000000..dd02df3 --- /dev/null +++ b/btl/generic_bench/static/static_size_generator.hh @@ -0,0 +1,57 @@ +//===================================================== +// File : static_size_generator.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, mar déc 3 18:59:36 CET 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef _STATIC_SIZE_GENERATOR_HH +#define _STATIC_SIZE_GENERATOR_HH +#include <vector> + +using namespace std; + +//recursive generation of statically defined matrix and vector sizes + +template <int SIZE,template<class> class Perf_Analyzer, template<class> class Action, template<class,int> class Interface> +struct static_size_generator{ + static void go(vector<double> & tab_sizes, vector<double> & tab_mflops) + { + tab_sizes.push_back(SIZE); + std::cout << tab_sizes.back() << " \t" << std::flush; + Perf_Analyzer<Action<Interface<REAL_TYPE,SIZE> > > perf_action; + tab_mflops.push_back(perf_action.eval_mflops(SIZE)); + std::cout << tab_mflops.back() << " MFlops" << std::endl; + static_size_generator<SIZE-1,Perf_Analyzer,Action,Interface>::go(tab_sizes,tab_mflops); + }; +}; + +//recursion end + +template <template<class> class Perf_Analyzer, template<class> class Action, template<class,int> class Interface> +struct static_size_generator<1,Perf_Analyzer,Action,Interface>{ + static void go(vector<double> & tab_sizes, vector<double> & tab_mflops) + { + tab_sizes.push_back(1); + Perf_Analyzer<Action<Interface<REAL_TYPE,1> > > perf_action; + tab_mflops.push_back(perf_action.eval_mflops(1)); + }; +}; + +#endif + + + + diff --git a/btl/generic_bench/timers/STL_perf_analyzer.hh b/btl/generic_bench/timers/STL_perf_analyzer.hh new file mode 100644 index 0000000..c9f894b --- /dev/null +++ b/btl/generic_bench/timers/STL_perf_analyzer.hh @@ -0,0 +1,82 @@ +//===================================================== +// File : STL_perf_analyzer.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, mar déc 3 18:59:35 CET 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef _STL_PERF_ANALYSER_HH +#define _STL_PERF_ANALYSER_HH + +#include "STL_timer.hh" +#include "bench_parameter.hh" + +template<class ACTION> +class STL_Perf_Analyzer{ +public: + STL_Perf_Analyzer(unsigned long long nb_sample=DEFAULT_NB_SAMPLE):_nb_sample(nb_sample),_chronos() + { + MESSAGE("STL_Perf_Analyzer Ctor"); + }; + STL_Perf_Analyzer( const STL_Perf_Analyzer & ){ + INFOS("Copy Ctor not implemented"); + exit(0); + }; + ~STL_Perf_Analyzer( void ){ + MESSAGE("STL_Perf_Analyzer Dtor"); + }; + + + inline double eval_mflops(int size) + { + + ACTION action(size); + + _chronos.start_baseline(_nb_sample); + + do { + + action.initialize(); + } while (_chronos.check()); + + double baseline_time=_chronos.get_time(); + + _chronos.start(_nb_sample); + do { + action.initialize(); + action.calculate(); + } while (_chronos.check()); + + double calculate_time=_chronos.get_time(); + + double corrected_time=calculate_time-baseline_time; + + // cout << size <<" "<<baseline_time<<" "<<calculate_time<<" "<<corrected_time<<" "<<action.nb_op_base() << endl; + + return action.nb_op_base()/(corrected_time*1000000.0); + //return action.nb_op_base()/(calculate_time*1000000.0); + + } +private: + + STL_Timer _chronos; + unsigned long long _nb_sample; + + +}; + + + +#endif diff --git a/btl/generic_bench/timers/STL_timer.hh b/btl/generic_bench/timers/STL_timer.hh new file mode 100644 index 0000000..19c54e9 --- /dev/null +++ b/btl/generic_bench/timers/STL_timer.hh @@ -0,0 +1,78 @@ +//===================================================== +// File : STL_Timer.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, mar déc 3 18:59:35 CET 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +// STL Timer Class. Adapted (L.P.) from the timer class by Musser et Al +// described int the Book : STL Tutorial and reference guide. +// Define a timer class for analyzing algorithm performance. +#include <iostream> +#include <iomanip> +#include <vector> +#include <map> +#include <algorithm> +using namespace std; + +class STL_Timer { +public: + STL_Timer(){ baseline = false; }; // Default constructor + // Start a series of r trials: + void start(unsigned int r){ + reps = r; + count = 0; + iterations.clear(); + iterations.reserve(reps); + initial = time(0); + }; + // Start a series of r trials to determine baseline time: + void start_baseline(unsigned int r) + { + baseline = true; + start(r); + } + // Returns true if the trials have been completed, else false + bool check() + { + ++count; + final = time(0); + if (initial < final) { + iterations.push_back(count); + initial = final; + count = 0; + } + return (iterations.size() < reps); + }; + // Returns the results for external use + double get_time( void ) + { + sort(iterations.begin(), iterations.end()); + return 1.0/iterations[reps/2]; + }; +private: + unsigned int reps; // Number of trials + // For storing loop iterations of a trial + vector<long> iterations; + // For saving initial and final times of a trial + time_t initial, final; + // For counting loop iterations of a trial + unsigned long count; + // true if this is a baseline computation, false otherwise + bool baseline; + // For recording the baseline time + double baseline_time; +}; + diff --git a/btl/generic_bench/timers/distributed_perf_analyzer_node.hh b/btl/generic_bench/timers/distributed_perf_analyzer_node.hh new file mode 100644 index 0000000..924eb87 --- /dev/null +++ b/btl/generic_bench/timers/distributed_perf_analyzer_node.hh @@ -0,0 +1,95 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef _PORTABLE_PERF_ANALYZER_NODE_HH +#define _PORTABLE_PERF_ANALYZER_NODE_HH + +#include "utilities.h" +#include "timers/portable_timer.hh" +#include "blacs.h" + +template <class Action> +class Distributed_Perf_Analyzer_Node{ +public: + Distributed_Perf_Analyzer_Node( ):_nb_calc(0){ + MESSAGE("Distributed_Perf_Analyzer_Node Ctor"); + int temp, what = 0; + blacs_get_(&temp, &what, &context); + }; + Distributed_Perf_Analyzer_Node( const Distributed_Perf_Analyzer_Node& ){ + INFOS("Copy Ctor not implemented"); + exit(0); + }; + ~Distributed_Perf_Analyzer_Node(){ + MESSAGE("Distributed_Perf_Analyzer_Node Dtor"); + }; + + BTL_DONT_INLINE double eval_mflops(int size, bool silent = false) + { + Action action(size); + + /* Find best _nb_calc_ */ + int bcast_receive, iZERO = 0, iONE = 1; + igebr2d_(&context, "A", " ", &iONE, &iONE, &bcast_receive, &iONE, &iZERO, &iZERO); + while (bcast_receive > 0) { + _nb_calc = bcast_receive; + action.initialize(); + time_calculate(action); + igebr2d_(&context, "A", " ", &iONE, &iONE, &bcast_receive, &iONE, &iZERO, &iZERO); + } + int tries = -bcast_receive; + + /* Optimize */ + for (int i = 1; i < tries; ++i) { + Action _action(size); + _action.initialize(); + time_calculate(_action); + } + + /* Check */ + int do_check; + igebr2d_(&context, "A", " ", &iONE, &iONE, &do_check, &iONE, &iZERO, &iZERO); + if (do_check > 0) { + action.initialize(); + action.calculate(); + action.check_result(); + } + + /* Return a void value */ + return 0.; + } + + BTL_DONT_INLINE void time_calculate(Action & action) + { + // no need for time measurement + action.calculate(); + for (int i = 0; i < _nb_calc; ++i) + action.calculate(); + } + + unsigned long long get_nb_calc() + { + return _nb_calc; + } + + +private: + int context; + unsigned long long _nb_calc; +}; + +#endif //_PORTABLE_PERF_ANALYZER_NODE_HH diff --git a/btl/generic_bench/timers/distributed_perf_analyzer_root.hh b/btl/generic_bench/timers/distributed_perf_analyzer_root.hh new file mode 100644 index 0000000..bbab901 --- /dev/null +++ b/btl/generic_bench/timers/distributed_perf_analyzer_root.hh @@ -0,0 +1,116 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef _PORTABLE_PERF_ANALYZER_ROOT_HH +#define _PORTABLE_PERF_ANALYZER_ROOT_HH + +#include "utilities.h" +#include "timers/portable_timer.hh" +#include "blacs.h" + +template <class Action> +class Distributed_Perf_Analyzer_Root{ +public: + Distributed_Perf_Analyzer_Root( ):_nb_calc(0), m_time_action(0), _chronos(){ + MESSAGE("Distributed_Perf_Analyzer_Root Ctor"); + int temp, what = 0; + blacs_get_(&temp, &what, &context); + }; + Distributed_Perf_Analyzer_Root( const Distributed_Perf_Analyzer_Root & ){ + INFOS("Copy Ctor not implemented"); + exit(0); + }; + ~Distributed_Perf_Analyzer_Root(){ + MESSAGE("Distributed_Perf_Analyzer_Root Dtor"); + }; + + BTL_DONT_INLINE double eval_mflops(int size, bool silent = false) + { + Action action(size); + m_time_action = 0; + _nb_calc = 0; + + /* Find best _nb_calc_ */ + int bcast_send = _nb_calc; + int iONE = 1; + while (m_time_action < MIN_TIME) { + _nb_calc = _nb_calc ? 2*_nb_calc : 1; + bcast_send = _nb_calc; + igebs2d_(&context, "A", " ", &iONE, &iONE, &bcast_send, &iONE); + action.initialize(); + m_time_action = time_calculate(action); + } + int tries = BtlConfig::Instance.tries; + bcast_send = -tries; + igebs2d_(&context, "A", " ", &iONE, &iONE, &bcast_send, &iONE); + + /* Optimize */ + for (int i = 1; i < tries; ++i) { + Action _action(size); + if (!silent) + std::cout << " " << _action.nb_op_base()*_nb_calc/(m_time_action*1e6) << " " << std::flush; + _action.initialize(); + m_time_action = std::min(m_time_action, time_calculate(_action)); + } + double time_action = m_time_action / (double(_nb_calc)); + + /* Check */ + int do_check = (BtlConfig::Instance.checkResults && size<128) ? 1 : 1; + igebs2d_(&context, "A", " ", &iONE, &iONE, &do_check, &iONE); + if (do_check > 0) { + action.initialize(); + action.calculate(); + action.check_result(); + } + + return action.nb_op_base()/(time_action*1e6); + } + + BTL_DONT_INLINE double time_calculate(Action & action) + { + // time measurement + action.calculate(); + _chronos.start(); + for (int ii=0; ii<_nb_calc; ii++) + { + action.calculate(); + } + _chronos.stop(); + + double user_time = _chronos.user_time(); + if (user_time < 0) { + std::cout << " { error: nb=" << _nb_calc << ", time=" << user_time << " } " << std::flush; + } + return user_time; + } + + unsigned long long get_nb_calc() + { + return _nb_calc; + } + + +private: + int context; + unsigned long long _nb_calc; + double m_time_action; + Portable_Timer _chronos; + +}; + +#endif //_PORTABLE_PERF_ANALYZER_ROOT_HH + diff --git a/btl/generic_bench/timers/mixed_perf_analyzer.hh b/btl/generic_bench/timers/mixed_perf_analyzer.hh new file mode 100644 index 0000000..e190236 --- /dev/null +++ b/btl/generic_bench/timers/mixed_perf_analyzer.hh @@ -0,0 +1,73 @@ +//===================================================== +// File : mixed_perf_analyzer.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, mar déc 3 18:59:36 CET 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef _MIXED_PERF_ANALYSER_HH +#define _MIXED_PERF_ANALYSER_HH + +#include "x86_perf_analyzer.hh" +#include "portable_perf_analyzer.hh" + +// choose portable perf analyzer for long calculations and x86 analyser for short ones + + +template<class Action> +class Mixed_Perf_Analyzer{ + +public: + Mixed_Perf_Analyzer( void ):_x86pa(),_ppa(),_use_ppa(true) + { + MESSAGE("Mixed_Perf_Analyzer Ctor"); + }; + Mixed_Perf_Analyzer( const Mixed_Perf_Analyzer & ){ + INFOS("Copy Ctor not implemented"); + exit(0); + }; + ~Mixed_Perf_Analyzer( void ){ + MESSAGE("Mixed_Perf_Analyzer Dtor"); + }; + + + inline double eval_mflops(int size) + { + + double result=0.0; + if (_use_ppa){ + result=_ppa.eval_mflops(size); + if (_ppa.get_nb_calc()>DEFAULT_NB_SAMPLE){_use_ppa=false;} + } + else{ + result=_x86pa.eval_mflops(size); + } + + return result; + } + +private: + + Portable_Perf_Analyzer<Action> _ppa; + X86_Perf_Analyzer<Action> _x86pa; + bool _use_ppa; + +}; + +#endif + + + + diff --git a/btl/generic_bench/timers/portable_perf_analyzer.hh b/btl/generic_bench/timers/portable_perf_analyzer.hh new file mode 100644 index 0000000..b207bde --- /dev/null +++ b/btl/generic_bench/timers/portable_perf_analyzer.hh @@ -0,0 +1,110 @@ +//===================================================== +// File : portable_perf_analyzer.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, mar d�c 3 18:59:35 CET 2002 +// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr> +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef _PORTABLE_PERF_ANALYZER_HH +#define _PORTABLE_PERF_ANALYZER_HH + +#include "utilities.h" +#include "timers/portable_timer.hh" +#include <iomanip> + +template <class Action> +class Portable_Perf_Analyzer{ +public: + Portable_Perf_Analyzer( ):_nb_calc(0), m_time_action(0), _chronos(){ + MESSAGE("Portable_Perf_Analyzer Ctor"); + }; + Portable_Perf_Analyzer( const Portable_Perf_Analyzer & ){ + INFOS("Copy Ctor not implemented"); + exit(0); + }; + ~Portable_Perf_Analyzer(){ + MESSAGE("Portable_Perf_Analyzer Dtor"); + }; + + BTL_DONT_INLINE double eval_mflops(int size, bool silent = false) + { + Action action(size); + + while (m_time_action < MIN_TIME) { + _nb_calc = _nb_calc ? 2*_nb_calc : 1; + action.initialize(); + m_time_action = time_calculate(action); + } + + // optimize + for (int i=1; i<BtlConfig::Instance.tries; ++i) + { + Action _action(size); + if (!silent) { + if (_action.nb_op_base()*_nb_calc < 0) + std::cout << " { op*calc = " << _action.nb_op_base()*_nb_calc << " } " << std::flush; + std::cout << " " << _action.nb_op_base()*_nb_calc/(m_time_action*1e6) << " "; + } + _action.initialize(); + m_time_action = std::min(m_time_action, time_calculate(_action)); + } + + double time_action = m_time_action / (double(_nb_calc)); + + // check + if (BtlConfig::Instance.checkResults && size<128) + { + action.initialize(); + action.calculate(); + action.check_result(); + } + return action.nb_op_base()/(time_action*1e6); + } + + BTL_DONT_INLINE double time_calculate(Action & action) + { + // time measurement + action.calculate(); + _chronos.start(); + for (int ii=0; ii<_nb_calc; ii++) + { + action.calculate(); + } + _chronos.stop(); + + double user_time = _chronos.user_time(); + if (user_time < 0) { + std::cout << " { error: nb=" << _nb_calc << ", time=" << user_time << " } " << std::flush; + } + return user_time; + } + + unsigned long long get_nb_calc() + { + return _nb_calc; + } + + +private: + unsigned long long _nb_calc; + double m_time_action; + Portable_Timer _chronos; + +}; + +#endif //_PORTABLE_PERF_ANALYZER_HH + diff --git a/btl/generic_bench/timers/portable_perf_analyzer_old.hh b/btl/generic_bench/timers/portable_perf_analyzer_old.hh new file mode 100644 index 0000000..fce3781 --- /dev/null +++ b/btl/generic_bench/timers/portable_perf_analyzer_old.hh @@ -0,0 +1,134 @@ +//===================================================== +// File : portable_perf_analyzer.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, mar d�c 3 18:59:35 CET 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef _PORTABLE_PERF_ANALYZER_HH +#define _PORTABLE_PERF_ANALYZER_HH + +#include "utilities.h" +#include "timers/portable_timer.hh" + +template <class Action> +class Portable_Perf_Analyzer{ +public: + Portable_Perf_Analyzer( void ):_nb_calc(1),_nb_init(1),_chronos(){ + MESSAGE("Portable_Perf_Analyzer Ctor"); + }; + Portable_Perf_Analyzer( const Portable_Perf_Analyzer & ){ + INFOS("Copy Ctor not implemented"); + exit(0); + }; + ~Portable_Perf_Analyzer( void ){ + MESSAGE("Portable_Perf_Analyzer Dtor"); + }; + + + + inline double eval_mflops(int size) + { + + Action action(size); + +// double time_baseline = time_init(action); +// while (time_baseline < MIN_TIME_INIT) +// { +// _nb_init *= 2; +// time_baseline = time_init(action); +// } +// +// // optimize +// for (int i=1; i<NB_TRIES; ++i) +// time_baseline = std::min(time_baseline, time_init(action)); +// +// time_baseline = time_baseline/(double(_nb_init)); + + double time_action = time_calculate(action); + while (time_action < MIN_TIME) + { + _nb_calc *= 2; + time_action = time_calculate(action); + } + + // optimize + for (int i=1; i<NB_TRIES; ++i) + time_action = std::min(time_action, time_calculate(action)); + +// INFOS("size="<<size); +// INFOS("_nb_init="<<_nb_init); +// INFOS("_nb_calc="<<_nb_calc); + + time_action = time_action / (double(_nb_calc)); + + action.check_result(); + + + double time_baseline = time_init(action); + for (int i=1; i<NB_TRIES; ++i) + time_baseline = std::min(time_baseline, time_init(action)); + time_baseline = time_baseline/(double(_nb_init)); + + + +// INFOS("time_baseline="<<time_baseline); +// INFOS("time_action="<<time_action); + + time_action = time_action - time_baseline; + +// INFOS("time_corrected="<<time_action); + + return action.nb_op_base()/(time_action*1000000.0); + } + + inline double time_init(Action & action) + { + // time measurement + _chronos.start(); + for (int ii=0; ii<_nb_init; ii++) + action.initialize(); + _chronos.stop(); + return _chronos.user_time(); + } + + + inline double time_calculate(Action & action) + { + // time measurement + _chronos.start(); + for (int ii=0;ii<_nb_calc;ii++) + { + action.initialize(); + action.calculate(); + } + _chronos.stop(); + return _chronos.user_time(); + } + + unsigned long long get_nb_calc( void ) + { + return _nb_calc; + } + + +private: + unsigned long long _nb_calc; + unsigned long long _nb_init; + Portable_Timer _chronos; + +}; + +#endif //_PORTABLE_PERF_ANALYZER_HH diff --git a/btl/generic_bench/timers/portable_timer.hh b/btl/generic_bench/timers/portable_timer.hh new file mode 100755 index 0000000..e6ad309 --- /dev/null +++ b/btl/generic_bench/timers/portable_timer.hh @@ -0,0 +1,145 @@ +//===================================================== +// File : portable_timer.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> from boost lib +// Copyright (C) EDF R&D, lun sep 30 14:23:17 CEST 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +// simple_time extracted from the boost library +// +#ifndef _PORTABLE_TIMER_HH +#define _PORTABLE_TIMER_HH + +#include <ctime> +#include <cstdlib> + +#include <time.h> + + +#define USEC_IN_SEC 1000000 + + +// timer -------------------------------------------------------------------// + +// A timer object measures CPU time. +#ifdef _MSC_VER + +#define NOMINMAX +#include <windows.h> + +/*#ifndef hr_timer +#include "hr_time.h" +#define hr_timer +#endif*/ + + class Portable_Timer + { + public: + + typedef struct { + LARGE_INTEGER start; + LARGE_INTEGER stop; + } stopWatch; + + + Portable_Timer() + { + startVal.QuadPart = 0; + stopVal.QuadPart = 0; + QueryPerformanceFrequency(&frequency); + } + + void start() { QueryPerformanceCounter(&startVal); } + + void stop() { QueryPerformanceCounter(&stopVal); } + + double elapsed() { + LARGE_INTEGER time; + time.QuadPart = stopVal.QuadPart - startVal.QuadPart; + return LIToSecs(time); + } + + double user_time() { return elapsed(); } + + + private: + + double LIToSecs(LARGE_INTEGER& L) { + return ((double)L.QuadPart /(double)frequency.QuadPart) ; + } + + LARGE_INTEGER startVal; + LARGE_INTEGER stopVal; + LARGE_INTEGER frequency; + + + }; // Portable_Timer + +#else + +#include <sys/time.h> +#include <sys/resource.h> +#include <unistd.h> +#include <sys/times.h> + +class Portable_Timer +{ + public: + + Portable_Timer() + { + m_clkid = BtlConfig::Instance.realclock ? CLOCK_REALTIME : CLOCK_PROCESS_CPUTIME_ID; + } + + Portable_Timer(int clkid) : m_clkid(clkid) + {} + + void start() + { + timespec ts; + clock_gettime(m_clkid, &ts); + m_start_time = double(ts.tv_sec) + 1e-9 * double(ts.tv_nsec); + + } + + void stop() + { + timespec ts; + clock_gettime(m_clkid, &ts); + m_stop_time = double(ts.tv_sec) + 1e-9 * double(ts.tv_nsec); + + } + + double elapsed() + { + return user_time(); + } + + double user_time() + { + return m_stop_time - m_start_time; + } + + +private: + + int m_clkid; + double m_stop_time, m_start_time; + +}; // Portable_Timer + +#endif + +#endif // PORTABLE_TIMER_HPP diff --git a/btl/generic_bench/timers/x86_perf_analyzer.hh b/btl/generic_bench/timers/x86_perf_analyzer.hh new file mode 100644 index 0000000..37ea21d --- /dev/null +++ b/btl/generic_bench/timers/x86_perf_analyzer.hh @@ -0,0 +1,108 @@ +//===================================================== +// File : x86_perf_analyzer.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, mar d�c 3 18:59:35 CET 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef _X86_PERF_ANALYSER_HH +#define _X86_PERF_ANALYSER_HH + +#include "x86_timer.hh" +#include "bench_parameter.hh" + +template<class ACTION> +class X86_Perf_Analyzer{ +public: + X86_Perf_Analyzer( unsigned long long nb_sample=DEFAULT_NB_SAMPLE):_nb_sample(nb_sample),_chronos() + { + MESSAGE("X86_Perf_Analyzer Ctor"); + _chronos.find_frequency(); + }; + X86_Perf_Analyzer( const X86_Perf_Analyzer & ){ + INFOS("Copy Ctor not implemented"); + exit(0); + }; + ~X86_Perf_Analyzer( void ){ + MESSAGE("X86_Perf_Analyzer Dtor"); + }; + + + inline double eval_mflops(int size) + { + + ACTION action(size); + + int nb_loop=5; + double calculate_time=0.0; + double baseline_time=0.0; + + for (int j=0 ; j < nb_loop ; j++){ + + _chronos.clear(); + + for(int i=0 ; i < _nb_sample ; i++) + { + _chronos.start(); + action.initialize(); + action.calculate(); + _chronos.stop(); + _chronos.add_get_click(); + } + + calculate_time += double(_chronos.get_shortest_clicks())/_chronos.frequency(); + + if (j==0) action.check_result(); + + _chronos.clear(); + + for(int i=0 ; i < _nb_sample ; i++) + { + _chronos.start(); + action.initialize(); + _chronos.stop(); + _chronos.add_get_click(); + + } + + baseline_time+=double(_chronos.get_shortest_clicks())/_chronos.frequency(); + + } + + double corrected_time = (calculate_time-baseline_time)/double(nb_loop); + + +// INFOS("_nb_sample="<<_nb_sample); +// INFOS("baseline_time="<<baseline_time); +// INFOS("calculate_time="<<calculate_time); +// INFOS("corrected_time="<<corrected_time); + +// cout << size <<" "<<baseline_time<<" "<<calculate_time<<" "<<corrected_time<<" "<<action.nb_op_base() << endl; + + return action.nb_op_base()/(corrected_time*1000000.0); + //return action.nb_op_base()/(calculate_time*1000000.0); + } + +private: + + X86_Timer _chronos; + unsigned long long _nb_sample; + + +}; + + + +#endif diff --git a/btl/generic_bench/timers/x86_timer.hh b/btl/generic_bench/timers/x86_timer.hh new file mode 100644 index 0000000..cfb5ee8 --- /dev/null +++ b/btl/generic_bench/timers/x86_timer.hh @@ -0,0 +1,246 @@ +//===================================================== +// File : x86_timer.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, mar d�c 3 18:59:35 CET 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef _X86_TIMER_HH +#define _X86_TIMER_HH + +#include <sys/time.h> +#include <sys/resource.h> +#include <unistd.h> +#include <sys/times.h> +//#include "system_time.h" +#define u32 unsigned int +#include <asm/msr.h> +#include "utilities.h" +#include <map> +#include <fstream> +#include <string> +#include <iostream> + +// frequence de la becanne en Hz +//#define FREQUENCY 648000000 +//#define FREQUENCY 1400000000 +#define FREQUENCY 1695000000 + +using namespace std; + + +class X86_Timer { + +public : + + X86_Timer( void ):_frequency(FREQUENCY),_nb_sample(0) + { + MESSAGE("X86_Timer Default Ctor"); + } + + inline void start( void ){ + + rdtsc(_click_start.n32[0],_click_start.n32[1]); + + } + + + inline void stop( void ){ + + rdtsc(_click_stop.n32[0],_click_stop.n32[1]); + + } + + + inline double frequency( void ){ + return _frequency; + } + + double get_elapsed_time_in_second( void ){ + + return (_click_stop.n64-_click_start.n64)/double(FREQUENCY); + + + } + + unsigned long long get_click( void ){ + + return (_click_stop.n64-_click_start.n64); + + } + + inline void find_frequency( void ){ + + time_t initial, final; + int dummy=2; + + initial = time(0); + start(); + do { + dummy+=2; + } + while(time(0)==initial); + // On est au debut d'un cycle d'une seconde !!! + initial = time(0); + start(); + do { + dummy+=2; + } + while(time(0)==initial); + final=time(0); + stop(); + // INFOS("fine grained time : "<< get_elapsed_time_in_second()); + // INFOS("coarse grained time : "<< final-initial); + _frequency=_frequency*get_elapsed_time_in_second()/double(final-initial); + /// INFOS("CPU frequency : "<< _frequency); + + } + + void add_get_click( void ){ + + _nb_sample++; + _counted_clicks[get_click()]++; + fill_history_clicks(); + + } + + void dump_statistics(string filemane){ + + ofstream outfile (filemane.c_str(),ios::out) ; + + std::map<unsigned long long , unsigned long long>::iterator itr; + for(itr=_counted_clicks.begin() ; itr!=_counted_clicks.end() ; itr++) + { + outfile << (*itr).first << " " << (*itr).second << endl ; + } + + outfile.close(); + + } + + void dump_history(string filemane){ + + ofstream outfile (filemane.c_str(),ios::out) ; + + + + for(int i=0 ; i<_history_mean_clicks.size() ; i++) + { + outfile << i << " " + << _history_mean_clicks[i] << " " + << _history_shortest_clicks[i] << " " + << _history_most_occured_clicks[i] << endl ; + } + + outfile.close(); + + } + + + + double get_mean_clicks( void ){ + + std::map<unsigned long long,unsigned long long>::iterator itr; + + unsigned long long mean_clicks=0; + + for(itr=_counted_clicks.begin() ; itr!=_counted_clicks.end() ; itr++) + { + + mean_clicks+=(*itr).second*(*itr).first; + } + + return mean_clicks/double(_nb_sample); + + } + + double get_shortest_clicks( void ){ + + return double((*_counted_clicks.begin()).first); + + } + + void fill_history_clicks( void ){ + + _history_mean_clicks.push_back(get_mean_clicks()); + _history_shortest_clicks.push_back(get_shortest_clicks()); + _history_most_occured_clicks.push_back(get_most_occured_clicks()); + + } + + + double get_most_occured_clicks( void ){ + + unsigned long long moc=0; + unsigned long long max_occurence=0; + + std::map<unsigned long long,unsigned long long>::iterator itr; + + for(itr=_counted_clicks.begin() ; itr!=_counted_clicks.end() ; itr++) + { + + if (max_occurence<=(*itr).second){ + max_occurence=(*itr).second; + moc=(*itr).first; + } + } + + return double(moc); + + } + + void clear( void ) + { + _counted_clicks.clear(); + + _history_mean_clicks.clear(); + _history_shortest_clicks.clear(); + _history_most_occured_clicks.clear(); + + _nb_sample=0; + } + + + +private : + + union + { + unsigned long int n32[2] ; + unsigned long long n64 ; + } _click_start; + + union + { + unsigned long int n32[2] ; + unsigned long long n64 ; + } _click_stop; + + double _frequency ; + + map<unsigned long long,unsigned long long> _counted_clicks; + + vector<double> _history_mean_clicks; + vector<double> _history_shortest_clicks; + vector<double> _history_most_occured_clicks; + + unsigned long long _nb_sample; + + + +}; + + +#endif diff --git a/btl/generic_bench/utils/LinearCongruential.hh b/btl/generic_bench/utils/LinearCongruential.hh new file mode 100644 index 0000000..3aa3716 --- /dev/null +++ b/btl/generic_bench/utils/LinearCongruential.hh @@ -0,0 +1,83 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef LINEARCONGRUENTIAL_HH_ +#define LINEARCONGRUENTIAL_HH_ + +#include <vector> + +class LinearCongruential +{ + typedef std::vector<unsigned> buffer_t; + typedef unsigned int_t; + +public: + LinearCongruential(const int_t& seed) : + a_(1664525u), c_(1013904223u), m_(getM()), i_(0) + { + buffer_.resize(4096/sizeof(unsigned)); + fillBuffer(seed); + } + + int_t a() const { return a_; } + int_t c() const { return c_; } + int_t m() const { return m_; } + + int_t get_int() { + if (i_ >= buffer_.size()) { + fillBuffer(); + i_ = 0; + } + return buffer_.at(i_++); + } + + double get_01() { + return static_cast<double>(get_int())/static_cast<double>(m_); + } + +private: + buffer_t buffer_; + const int_t a_, c_, m_; + std::size_t i_; + + void fillBuffer(const int_t& seed) + { + buffer_.front() = (seed*a_+c_) & m_; + for ( + typename buffer_t::iterator i = buffer_.begin()+1, end = buffer_.end(); + i != end; ++i) + *i = (*(i-1)*a_ + c_) & m_; + } + + void fillBuffer() + { + const int_t seed = buffer_.back(); + fillBuffer(seed); + } + + static int_t getM() + { + int_t _m = 1; + for (int i = 1; i < 32; ++i) { + _m <<= 1; + _m += 1; + } + return _m; + } +}; + +#endif /* LINEARCONGRUENTIAL_HH_ */ diff --git a/btl/generic_bench/utils/size_lin_log.hh b/btl/generic_bench/utils/size_lin_log.hh new file mode 100644 index 0000000..7c272c0 --- /dev/null +++ b/btl/generic_bench/utils/size_lin_log.hh @@ -0,0 +1,70 @@ +//===================================================== +// File : size_lin_log.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, mar déc 3 18:59:37 CET 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef SIZE_LIN_LOG +#define SIZE_LIN_LOG + +#include "size_log.hh" + +template<class Vector> +void size_lin_log(const int nb_point, const int size_min, const int size_max, Vector & X) +{ + int ten=10; + int nine=9; + + X.resize(nb_point); + + if (nb_point>ten){ + + for (int i=0;i<nine;i++){ + + X[i]=i+size_min; + + } + + Vector log_size; + size_log(nb_point-nine,nine+size_min,size_max,log_size); + + for (int i=0;i<nb_point-nine;i++){ + + X[i+nine]=log_size[i]; + + } + } + else{ + + for (int i=0;i<nb_point;i++){ + + X[i]=i+1; + + } + } + + // for (int i=0;i<nb_point;i++){ + +// INFOS("computed sizes : X["<<i<<"]="<<X[i]); + +// } + +} + +#endif + + + diff --git a/btl/generic_bench/utils/size_log.hh b/btl/generic_bench/utils/size_log.hh new file mode 100644 index 0000000..13a3da7 --- /dev/null +++ b/btl/generic_bench/utils/size_log.hh @@ -0,0 +1,54 @@ +//===================================================== +// File : size_log.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, lun sep 30 14:23:17 CEST 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef SIZE_LOG +#define SIZE_LOG + +#include "math.h" +// The Vector class must satisfy the following part of STL vector concept : +// resize() method +// [] operator for seting element +// the vector element are int compatible. +template<class Vector> +void size_log(const int nb_point, const int size_min, const int size_max, Vector & X) +{ + X.resize(nb_point); + + float ls_min=log(float(size_min)); + float ls_max=log(float(size_max)); + + float ls=0.0; + + float delta_ls=(ls_max-ls_min)/(float(nb_point-1)); + + int size=0; + + for (int i=0;i<nb_point;i++){ + + ls = ls_min + float(i)*delta_ls ; + + size=int(exp(ls)); + + X[i]=size; + } + +} + + +#endif diff --git a/btl/generic_bench/utils/utilities.h b/btl/generic_bench/utils/utilities.h new file mode 100644 index 0000000..d2330d0 --- /dev/null +++ b/btl/generic_bench/utils/utilities.h @@ -0,0 +1,90 @@ +//============================================================================= +// File : utilities.h +// Created : mar jun 19 13:18:14 CEST 2001 +// Author : Antoine YESSAYAN, Paul RASCLE, EDF +// Project : SALOME +// Copyright : EDF 2001 +// $Header$ +//============================================================================= + +/* --- Definition macros file to print information if _DEBUG_ is defined --- */ + +# ifndef UTILITIES_H +# define UTILITIES_H + +# include <stdlib.h> +//# include <iostream> ok for gcc3.01 +# include <iostream> + +/* --- INFOS is always defined (without _DEBUG_): to be used for warnings, with release version --- */ + +# define HEREWEARE cout<<flush ; cerr << __FILE__ << " [" << __LINE__ << "] : " << flush ; +# define INFOS(chain) {HEREWEARE ; cerr << chain << endl ;} +# define PYSCRIPT(chain) {cout<<flush ; cerr << "---PYSCRIPT--- " << chain << endl ;} + +/* --- To print date and time of compilation of current source on stdout --- */ + +# if defined ( __GNUC__ ) +# define COMPILER "g++" ; +# elif defined ( __sun ) +# define COMPILER "CC" ; +# elif defined ( __KCC ) +# define COMPILER "KCC" ; +# elif defined ( __PGI ) +# define COMPILER "pgCC" ; +# else +# define COMPILER "undefined" ; +# endif + +# ifdef INFOS_COMPILATION +# error INFOS_COMPILATION already defined +# endif +# define INFOS_COMPILATION {\ + cerr << flush;\ + cout << __FILE__ ;\ + cout << " [" << __LINE__ << "] : " ;\ + cout << "COMPILED with " << COMPILER ;\ + cout << ", " << __DATE__ ; \ + cout << " at " << __TIME__ << endl ;\ + cout << "\n\n" ;\ + cout << flush ;\ + } + +# ifdef _DEBUG_ + +/* --- the following MACROS are useful at debug time --- */ + +# define HERE cout<<flush ; cerr << "- Trace " << __FILE__ << " [" << __LINE__ << "] : " << flush ; +# define SCRUTE(var) HERE ; cerr << #var << "=" << var << endl ; +# define MESSAGE(chain) {HERE ; cerr << chain << endl ;} +# define INTERRUPTION(code) HERE ; cerr << "INTERRUPTION return code= " << code << endl ; exit(code) ; + +# ifndef ASSERT +# define ASSERT(condition) if (!(condition)){ HERE ; cerr << "CONDITION " << #condition << " NOT VERIFIED"<< endl ; INTERRUPTION(1) ;} +# endif /* ASSERT */ + +#define REPERE cout<<flush ; cerr << " --------------" << endl << flush ; +#define BEGIN_OF(chain) {REPERE ; HERE ; cerr << "Begin of: " << chain << endl ; REPERE ; } +#define END_OF(chain) {REPERE ; HERE ; cerr << "Normal end of: " << chain << endl ; REPERE ; } + + + +# else /* ifdef _DEBUG_*/ + +# define HERE +# define SCRUTE(var) +# define MESSAGE(chain) +# define INTERRUPTION(code) + +# ifndef ASSERT +# define ASSERT(condition) +# endif /* ASSERT */ + +#define REPERE +#define BEGIN_OF(chain) +#define END_OF(chain) + + +# endif /* ifdef _DEBUG_*/ + +# endif /* ifndef UTILITIES_H */ diff --git a/btl/generic_bench/utils/xy_file.hh b/btl/generic_bench/utils/xy_file.hh new file mode 100644 index 0000000..4571bed --- /dev/null +++ b/btl/generic_bench/utils/xy_file.hh @@ -0,0 +1,75 @@ +//===================================================== +// File : dump_file_x_y.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, lun sep 30 14:23:20 CEST 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef XY_FILE_HH +#define XY_FILE_HH +#include <fstream> +#include <iostream> +#include <string> +#include <vector> +using namespace std; + +bool read_xy_file(const std::string & filename, std::vector<int> & tab_sizes, + std::vector<double> & tab_mflops, bool quiet = false) +{ + + std::ifstream input_file (filename.c_str(),std::ios::in); + + if (!input_file){ + if (!quiet) { + INFOS("!!! Error opening "<<filename); + } + return false; + } + + int nb_point=0; + int size=0; + double mflops=0; + + while (input_file >> size >> mflops ){ + nb_point++; + tab_sizes.push_back(size); + tab_mflops.push_back(mflops); + } + SCRUTE(nb_point); + + input_file.close(); + return true; +} + +// The Vector class must satisfy the following part of STL vector concept : +// resize() method +// [] operator for seting element +// the vector element must have the << operator define + +using namespace std; + +template<class Vector_A, class Vector_B> +void dump_xy_file(const Vector_A & X, const Vector_B & Y, const std::string & filename){ + + ofstream outfile (filename.c_str(),ios::out) ; + int size=X.size(); + + for (int i=0;i<size;i++) + outfile << X[i] << " " << Y[i] << endl; + + outfile.close(); +} + +#endif diff --git a/btl/libs/BLACS/blacs.h b/btl/libs/BLACS/blacs.h new file mode 100644 index 0000000..97c863b --- /dev/null +++ b/btl/libs/BLACS/blacs.h @@ -0,0 +1,50 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef BLACS_H_ +#define BLACS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + + /* BLACS declarations */ + void blacs_pinfo_(int*, int*); + void blacs_get_(int*, int*, int*); + void blacs_gridinit_(int*, const char*, int*, int*); + void blacs_gridinfo_(const int*, int*, int*, int*, int*); + void blacs_pcoord_(const int*, const int*, int*, int*); + void blacs_gridexit_(int*); + void blacs_exit_(int*); + void blacs_barrier_(const int*, const char*); + void dgerv2d_(const int*, const int*, const int*, double*, const int*, const int*, const int*); + void dgesd2d_(const int*, const int*, const int*, const double*, const int*, const int*, const int*); + void sgerv2d_(const int*, const int*, const int*, float*, const int*, const int*, const int*); + void sgesd2d_(const int*, const int*, const int*, const float*, const int*, const int*, const int*); + void igebs2d_(const int*, const char*, const char*, const int*, const int*, const int*, const int*); + void igebr2d_(const int*, const char*, const char*, const int*, const int*, int*, const int*, const int*, const int*); + void dgebs2d_(const int*, const char*, const char*, const int*, const int*, const double*, const int*); + void dgebr2d_(const int*, const char*, const char*, const int*, const int*, double*, const int*, const int*, const int*); + void dgsum2d_(const int*, const char*, const char*, const int*, const int*, double*, const int*, const int*, const int*); + void igsum2d_(const int*, const char*, const char*, const int*, const int*, int*, const int*, const int*, const int*); + +#ifdef __cplusplus +} +#endif + + +#endif /* BLACS_H_ */ diff --git a/btl/libs/BLACS/blacs_interface.hh b/btl/libs/BLACS/blacs_interface.hh new file mode 100644 index 0000000..09f57b3 --- /dev/null +++ b/btl/libs/BLACS/blacs_interface.hh @@ -0,0 +1,153 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef BTL_BLACS_INTERFACE_H +#define BTL_BLACS_INTERFACE_H + +#include <vector> +#include <algorithm> +#include "blacs.h" +extern "C" { + void descinit_(int*, const int*, const int*, const int*, const int*, const int*, const int*, const int*, const int*, int*); + int numroc_(const int*, const int*, const int*, const int*, const int*); +} + +#include "scatter.h" +#include "gather.h" + +template<typename real> +class blacs_interface +{ + +public: + typedef real real_type; + typedef std::vector<real_type> stl_vector; + typedef stl_vector stl_matrix; + + typedef real* gene_matrix; + typedef real* gene_vector; + + + static void free_matrix(gene_matrix & A, int N){ + delete A; + } + + static void free_vector(gene_vector & B){ + delete B; + } + + static inline void matrix_from_stl(gene_matrix & A, stl_matrix & A_stl){ + int N = A_stl.size(); + A = new real[N]; + for (int j=0;j<N;j++) + A[j] = A_stl[j]; + } + + static inline void vector_from_stl(gene_vector & B, stl_vector & B_stl){ + int N = B_stl.size(); + B = new real[N]; + for (int i=0;i<N;i++) + B[i] = B_stl[i]; + } + + static inline void vector_to_stl(gene_vector & B, stl_vector & B_stl){ + int N = B_stl.size(); + for (int i=0;i<N;i++) + B_stl[i] = B[i]; + } + + static inline void matrix_to_stl(gene_matrix & A, stl_matrix & A_stl){ + int N = A_stl.size(); + for (int i=0;i<N;i++) + A_stl[i] = A[i]; + } + + static inline void copy_vector(const gene_vector & source, gene_vector & cible, int N){ + for (int i=0;i<N;i++) + cible[i]=source[i]; + } + + static inline void copy_matrix(const gene_matrix & source, gene_matrix & cible, int N){ + for (int i=0;i<N;i++) + cible[i]=source[i]; + } + + +public: + static int context() { + int ctxt, ignored, what = 0; + blacs_get_(&ignored, &what, &ctxt); + return ctxt; + } + static int myid() { + int procnum, myid; + blacs_pinfo_(&myid, &procnum); + return myid; + } + + + static void scatter_matrix(const stl_vector& GlobalMatrix, stl_vector& LocalMatrix, + int& GlobalRows, int& GlobalCols, + int& BlockRows, int& BlockCols, + int& LocalRows, int& LocalCols + ) { + scatter(context(), GlobalMatrix, LocalMatrix, GlobalRows, GlobalCols, BlockRows, BlockCols, LocalRows, LocalCols); + } + + static void scatter_matrix(const stl_vector& GlobalMatrix, stl_vector& LocalMatrix, + int *desc, + const int& GlobalRows=0, const int& GlobalCols=0, + const int& BlockRows=0, const int& BlockCols=0 + ) { + int GlobalRows_ = GlobalRows, GlobalCols_ = GlobalCols, + BlockRows_ = BlockRows, BlockCols_ = BlockCols, + LocalRows_, LocalCols_; + const int ctxt = context(); + scatter(ctxt, GlobalMatrix, LocalMatrix, + GlobalRows_, GlobalCols_, BlockRows_, BlockCols_, LocalRows_, LocalCols_ + ); + + const int iZERO = 0; + int info; + const int LLD = std::max(1, LocalRows_); + descinit_(desc, &GlobalRows_, &GlobalCols_, &BlockRows_, &BlockCols_, + &iZERO, &iZERO, &ctxt, &LLD, &info + ); + } + + static void gather_matrix(stl_vector& GlobalMatrix, const stl_vector& LocalMatrix, + int& GlobalRows, int& GlobalCols, + int& BlockRows, int& BlockCols, + int& LocalRows, int& LocalCols + ) { + gather(context(), GlobalMatrix, LocalMatrix, GlobalRows, GlobalCols, BlockRows, BlockCols, LocalRows, LocalCols); + } + + static void gather_matrix(stl_vector& GlobalMatrix, const stl_vector& LocalMatrix, + int* desc + ) { + int GlobalRows = desc[2], GlobalCols = desc[3], + BlockRows = desc[4], BlockCols = desc[5], + LocalRows = desc[8], LocalCols = LocalMatrix.size()/desc[8]; + const int ctxt = context(); + gather(ctxt, GlobalMatrix, LocalMatrix, GlobalRows, GlobalCols, BlockRows, BlockCols, LocalRows, LocalCols); + } + + +}; + +#endif /* BTL_BLACS_INTERFACE_H */ diff --git a/btl/libs/BLACS/blacsinit.hh b/btl/libs/BLACS/blacsinit.hh new file mode 100644 index 0000000..41f5ebf --- /dev/null +++ b/btl/libs/BLACS/blacsinit.hh @@ -0,0 +1,38 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef BLACSINIT_HH +#define BLACSINIT_HH + +#include <cmath> + +bool blacsinit(int *argc, char ***argv) +{ + int context, myid, numproc, prows, pcols, iZERO = 0; + MPI_Init(argc, argv); + blacs_pinfo_(&myid, &numproc); + blacs_get_(&iZERO, &iZERO, &context); + + int p = static_cast<double>(std::sqrt(static_cast<double>(numproc)) + 1.); + while (numproc % p) --p; + prows = p; pcols = numproc/p; + + blacs_gridinit_(&context, "Row-major", &prows, &pcols); + return (myid == 0); +} + +#endif /* BLACSINIT_HH */ diff --git a/btl/libs/BLACS/gather.h b/btl/libs/BLACS/gather.h new file mode 100644 index 0000000..957f7c7 --- /dev/null +++ b/btl/libs/BLACS/gather.h @@ -0,0 +1,49 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef GATHER_H_ +#define GATHER_H_ + +#define TYPENAME float +#define TYPEPREFIX s +#include "gather_impl.h" +#undef TYPENAME +#undef TYPEPREFIX + +#define TYPENAME double +#define TYPEPREFIX d +#include "gather_impl.h" +#undef TYPENAME +#undef TYPEPREFIX + +template<typename T> +static void gather_matrix(std::vector<T>& GlobalMatrix, const std::vector<T>& LocalMatrix, + const int* desc +) { + int GlobalRows = desc[2], GlobalCols = desc[3], + BlockRows = desc[4], BlockCols = desc[5], + LocalRows = desc[8], LocalCols = LocalMatrix.size()/desc[8]; + int ctxt; + { + int ignored, what = 0; + blacs_get_(&ignored, &what, &ctxt); + } + gather(ctxt, GlobalMatrix, LocalMatrix, GlobalRows, GlobalCols, BlockRows, BlockCols, LocalRows, LocalCols); +} + + +#endif /* GATHER_H_ */ diff --git a/btl/libs/BLACS/gather_impl.h b/btl/libs/BLACS/gather_impl.h new file mode 100644 index 0000000..3b57d57 --- /dev/null +++ b/btl/libs/BLACS/gather_impl.h @@ -0,0 +1,126 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#define PRFX d +#define CAT_(x,y) x##y +#define CAT(x,y) CAT_(x,y) + +#define FUNCNAME(name) CAT(CAT(TYPEPREFIX, name),_) +#define vector_t std::vector<TYPENAME> + +#include <vector> + + +inline void gather( + const int& context, // [IN] + vector_t& GlobalMatrixVector, // [OUT] Only relevant for root + const vector_t& LocalMatrixVector, // [IN] + int& GlobalRows, // [OUT] + int& GlobalCols, // [OUT] + int& BlockRows, // [IN (root) / OUT (other)] + int& BlockCols, // [IN (root) / OUT (other)] + int& LocalRows, // [IN] + int& LocalCols, // [IN] + const int& rootrow = 0, // [IN] + const int& rootcol = 0 // [IN] +) { + /* Helper variables */ + int iONE = 1, iTWO = 2, imONE = -1; + + int myid, myrow, mycol, procrows, proccols, procnum; + blacs_pinfo_(&myid, &procnum); + blacs_gridinfo_(&context, &procrows, &proccols, &myrow, &mycol); + bool iamroot = (myrow == rootrow && mycol == rootcol); + TYPENAME *GlobalMatrix; + const TYPENAME *LocalMatrix = &LocalMatrixVector[0]; + + /* Broadcast matrix info */ + int binfo[2]; + if (iamroot) { + binfo[0] = BlockRows; + binfo[1] = BlockCols; + + igebs2d_(&context, "All", " ", &iTWO, &iONE, binfo, &iTWO); + } else { + igebr2d_(&context, "All", " ", &iTWO, &iONE, binfo, &iTWO, + &rootrow, &rootcol); + } + BlockRows = binfo[0]; + BlockCols = binfo[1]; + + /* Retrieve matrix global dimensions */ + int minfo[2]; + minfo[0] = LocalRows; minfo[1] = LocalCols; + igsum2d_(&context, "Col", " ", &iONE, &iONE, minfo, &iONE, &imONE, &imONE); + igsum2d_(&context, "Row", " ", &iONE, &iONE, minfo+1, &iONE, &imONE, &imONE); + GlobalRows = minfo[0]; GlobalCols = minfo[1]; + + + /* Reserve space on root */ + if (iamroot) { + GlobalMatrixVector.resize(GlobalRows*GlobalCols); + GlobalMatrix = &GlobalMatrixVector[0]; + } + + /* Gather matrix */ + int srcr = 0, srcc = 0; + int SendRows, SendCols; + int StartRow = 0, StartCol = 0; + for (int r = 0; r < GlobalRows; r += BlockRows, srcr=(srcr+1)%procrows) { + srcc = 0; + + // Is this the last row bloc? + SendRows = BlockRows; + if (GlobalRows-r < BlockRows) + SendRows = GlobalRows-r; + if (SendRows <= 0) + SendRows = 0; + + for (int c=0; c<GlobalCols; c+=BlockCols, srcc=(srcc+1)%proccols) { + + // Is this the last column block? + SendCols = BlockCols; + if (GlobalCols-c < BlockCols) + SendCols = GlobalCols-c; + + // Send data + if (myrow == srcr && mycol == srcc) { + FUNCNAME(gesd2d) (&context, &SendRows, &SendCols, + LocalMatrix+LocalRows*StartCol+StartRow, + &LocalRows, &rootrow, &rootcol + ); + + // Adjust the next starting column + StartCol = (StartCol + SendCols) % LocalCols; + } + + // Receive data + if (iamroot) { + FUNCNAME(gerv2d) (&context, &SendRows, &SendCols, + GlobalMatrix + GlobalRows*c + r, + &GlobalRows, &srcr, &srcc + ); + } + } + + // Adjust the next starting row + if (myrow == srcr) + StartRow = (StartRow + SendRows) % LocalRows; + + } + +} diff --git a/btl/libs/BLACS/scatter.h b/btl/libs/BLACS/scatter.h new file mode 100644 index 0000000..170e82a --- /dev/null +++ b/btl/libs/BLACS/scatter.h @@ -0,0 +1,61 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef SCATTER_H_ +#define SCATTER_H_ + +#define TYPENAME float +#define TYPEPREFIX s +#include "scatter_impl.h" +#undef TYPENAME +#undef TYPEPREFIX + +#define TYPENAME double +#define TYPEPREFIX d +#include "scatter_impl.h" +#undef TYPENAME +#undef TYPEPREFIX + +template<typename T> +void scatter_matrix(const std::vector<T>& GlobalMatrix, std::vector<T>& LocalMatrix, + int *desc, + const int& GlobalRows=0, const int& GlobalCols=0, + const int& BlockRows=0, const int& BlockCols=0 + ) +{ + int GlobalRows_ = GlobalRows, GlobalCols_ = GlobalCols, + BlockRows_ = BlockRows, BlockCols_ = BlockCols, + LocalRows_, LocalCols_; + int ctxt; + { + int ignored, what = 0; + blacs_get_(&ignored, &what, &ctxt); + } + scatter(ctxt, GlobalMatrix, LocalMatrix, + GlobalRows_, GlobalCols_, BlockRows_, BlockCols_, LocalRows_, LocalCols_ + ); + + const int iZERO = 0; + int info; + const int LLD = std::max(1, LocalRows_); + descinit_(desc, &GlobalRows_, &GlobalCols_, &BlockRows_, &BlockCols_, + &iZERO, &iZERO, &ctxt, &LLD, &info + ); +} + + +#endif /* SCATTER_H_ */ diff --git a/btl/libs/BLACS/scatter_impl.h b/btl/libs/BLACS/scatter_impl.h new file mode 100644 index 0000000..7c38c22 --- /dev/null +++ b/btl/libs/BLACS/scatter_impl.h @@ -0,0 +1,121 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#define CAT_(x,y) x##y +#define CAT(x,y) CAT_(x,y) + +#define FUNCNAME(name) CAT(CAT(TYPEPREFIX, name),_) +#define vector_t std::vector<TYPENAME> + +#include <vector> + +inline void scatter( + const int& context, // [IN] + const vector_t& GlobalMatrixVector, // [IN] Only relevant for root + vector_t& LocalMatrixVector, // [OUT] The space is reserved here + int& GlobalRows, // [IN (root) / OUT (other)] + int& GlobalCols, // [IN (root) / OUT (other)] + int& BlockRows, // [IN (root) / OUT (other)] + int& BlockCols, // [IN (root) / OUT (other)] + int& LocalRows, // [OUT] + int& LocalCols, // [OUT] + const int& rootrow = 0, // [IN] + const int& rootcol = 0 // [IN] +) { + /* Helper variables */ + int iZERO = 0, iONE = 1, iFOUR = 4; + + int myid, myrow, mycol, procrows, proccols, procnum; + blacs_pinfo_(&myid, &procnum); + blacs_gridinfo_(&context, &procrows, &proccols, &myrow, &mycol); + bool iamroot = (myrow == rootrow && mycol == rootcol); + const TYPENAME *GlobalMatrix = &GlobalMatrixVector[0]; + TYPENAME *LocalMatrix; + + /* Broadcast matrix info */ + int minfo[4]; + if (iamroot) { + minfo[0] = GlobalRows; + minfo[1] = GlobalCols; + minfo[2] = BlockRows; + minfo[3] = BlockCols; + igebs2d_(&context, "All", " ", &iFOUR, &iONE, minfo, &iFOUR); + } else { + igebr2d_(&context, "All", " ", &iFOUR, &iONE, minfo, &iFOUR, + &iZERO, &iZERO); + } + + GlobalRows = minfo[0]; + GlobalCols = minfo[1]; + BlockRows = minfo[2]; + BlockCols = minfo[3]; + + + /* Reserve space */ + LocalRows = numroc_(&GlobalRows, &BlockRows, &myrow, &iZERO, &procrows); + LocalCols = numroc_(&GlobalCols, &BlockCols, &mycol, &iZERO, &proccols); + LocalMatrixVector.resize(LocalRows*LocalCols); + LocalMatrix = &LocalMatrixVector[0]; + + /* Scatter matrix */ + int destr = 0, destc = 0; + int SendRows, SendCols; + int RecvRow = 0, RecvCol = 0; + for (int r = 0; r < GlobalRows; r += BlockRows, destr=(destr+1)%procrows) { + destc = 0; + + // Is this the last row bloc? + SendRows = BlockRows; + if (GlobalRows-r < BlockRows) + SendRows = GlobalRows-r; + if (SendRows <= 0) + SendRows = 0; + + for (int c=0; c<GlobalCols; c+=BlockCols, destc=(destc+1)%proccols) { + + // Is this the last column block? + SendCols = BlockCols; + if (GlobalCols-c < BlockCols) + SendCols = GlobalCols-c; + + // Send data + if (iamroot) { + FUNCNAME(gesd2d) (&context, &SendRows, &SendCols, + GlobalMatrix + GlobalRows*c + r, + &GlobalRows, &destr, &destc + ); + } + + // Rerceive data + if (myrow == destr && mycol == destc) { + FUNCNAME(gerv2d) (&context, &SendRows, &SendCols, + LocalMatrix+LocalRows*RecvCol+RecvRow, + &LocalRows, &rootrow, &rootcol + ); + + // Adjust the next starting column + RecvCol = (RecvCol + SendCols) % LocalCols; + } + } + + // Adjust the next starting row + if (myrow == destr) + RecvRow = (RecvRow + SendRows) % LocalRows; + + } + +} diff --git a/btl/libs/BLAS/CMakeLists.txt b/btl/libs/BLAS/CMakeLists.txt new file mode 100644 index 0000000..de42fe0 --- /dev/null +++ b/btl/libs/BLAS/CMakeLists.txt @@ -0,0 +1,60 @@ + +find_package(ATLAS) +if (ATLAS_FOUND) + btl_add_bench(btl_atlas main.cpp) + if(BUILD_btl_atlas) + target_link_libraries(btl_atlas ${ATLAS_LIBRARIES}) + set_target_properties(btl_atlas PROPERTIES COMPILE_FLAGS "-DCBLASNAME=ATLAS -DHAS_LAPACK=1") + endif(BUILD_btl_atlas) +endif (ATLAS_FOUND) + +find_package(MKL) +if (MKL_FOUND) + btl_add_bench(btl_mkl main.cpp) + if(BUILD_btl_mkl) + target_link_libraries(btl_mkl ${MKL_LIBRARIES}) + set_target_properties(btl_mkl PROPERTIES COMPILE_FLAGS "-DCBLASNAME=INTEL_MKL -DHAS_LAPACK=1") + endif(BUILD_btl_mkl) +endif (MKL_FOUND) + + +find_package(GOTO2) +if (GOTO2_FOUND) + btl_add_bench(btl_goto2 main.cpp) + if(BUILD_btl_goto2) + target_link_libraries(btl_goto2 ${GOTO_LIBRARIES} ) + set_target_properties(btl_goto2 PROPERTIES COMPILE_FLAGS "-DCBLASNAME=GOTO2") + endif(BUILD_btl_goto2) +endif (GOTO2_FOUND) + +find_package(GOTO) +if (GOTO_FOUND) + if(GOTO2_FOUND) + btl_add_bench(btl_goto main.cpp OFF) + else() + btl_add_bench(btl_goto main.cpp) + endif() + if(BUILD_btl_goto) + target_link_libraries(btl_goto ${GOTO_LIBRARIES} ) + set_target_properties(btl_goto PROPERTIES COMPILE_FLAGS "-DCBLASNAME=GOTO") + endif(BUILD_btl_goto) +endif (GOTO_FOUND) + +find_package(ACML) +if (ACML_FOUND) + btl_add_bench(btl_acml main.cpp) + if(BUILD_btl_acml) + target_link_libraries(btl_acml ${ACML_LIBRARIES} ) + set_target_properties(btl_acml PROPERTIES COMPILE_FLAGS "-DCBLASNAME=ACML -DHAS_LAPACK=1") + endif(BUILD_btl_acml) +endif (ACML_FOUND) + +if(Eigen_SOURCE_DIR AND CMAKE_Fortran_COMPILER_WORKS) + # we are inside Eigen and blas/lapack interface is compilable + include_directories(${Eigen_SOURCE_DIR}) + btl_add_bench(btl_eigenblas main.cpp) + if(BUILD_btl_eigenblas) + target_link_libraries(btl_eigenblas eigen_blas eigen_lapack ) + set_target_properties(btl_eigenblas PROPERTIES COMPILE_FLAGS "-DCBLASNAME=EigenBLAS") + endif() +endif() diff --git a/btl/libs/BLAS/blas.h b/btl/libs/BLAS/blas.h new file mode 100644 index 0000000..25607a5 --- /dev/null +++ b/btl/libs/BLAS/blas.h @@ -0,0 +1,681 @@ +#ifndef BLAS_H +#define BLAS_H + +#define BLASFUNC(FUNC) FUNC##_ + +#ifdef __WIN64__ +typedef long long BLASLONG; +typedef unsigned long long BLASULONG; +#else +typedef long BLASLONG; +typedef unsigned long BLASULONG; +#endif + +#include <complex> + +extern "C" { + +int BLASFUNC(xerbla)(const char *, int *info, int); + +float BLASFUNC(sdot) (int *, float *, int *, float *, int *); +float BLASFUNC(sdsdot)(int *, float *, float *, int *, float *, int *); + +double BLASFUNC(dsdot) (int *, float *, int *, float *, int *); +double BLASFUNC(ddot) (int *, double *, int *, double *, int *); +double BLASFUNC(qdot) (int *, double *, int *, double *, int *); + +#if defined(F_INTERFACE_GFORT) && !defined(__64BIT__) +int BLASFUNC(cdotu) (int *, float * , int *, float *, int *); +int BLASFUNC(cdotc) (int *, float *, int *, float *, int *); +void BLASFUNC(zdotu) (double *, int *, double *, int *, double *, int *); +void BLASFUNC(zdotc) (double *, int *, double *, int *, double *, int *); +void BLASFUNC(xdotu) (double *, int *, double *, int *, double *, int *); +void BLASFUNC(xdotc) (double *, int *, double *, int *, double *, int *); +#elif defined(F_INTERFACE_F2C) || \ + defined(F_INTERFACE_PGI) || \ + defined(F_INTERFACE_GFORT) || \ + (defined(F_INTERFACE_PATHSCALE) && defined(__64BIT__)) +void BLASFUNC(cdotu) (float *, int *, float * , int *, float *, int *); +void BLASFUNC(cdotc) (float *, int *, float *, int *, float *, int *); +void BLASFUNC(zdotu) (double *, int *, double *, int *, double *, int *); +void BLASFUNC(zdotc) (double *, int *, double *, int *, double *, int *); +void BLASFUNC(xdotu) (double *, int *, double *, int *, double *, int *); +void BLASFUNC(xdotc) (double *, int *, double *, int *, double *, int *); +#else +std::complex<float> BLASFUNC(cdotu) (int *, float *, int *, float *, int *); +std::complex<float> BLASFUNC(cdotc) (int *, float *, int *, float *, int *); +std::complex<double> BLASFUNC(zdotu) (int *, double *, int *, double *, int *); +std::complex<double> BLASFUNC(zdotc) (int *, double *, int *, double *, int *); +double BLASFUNC(xdotu) (int *, double *, int *, double *, int *); +double BLASFUNC(xdotc) (int *, double *, int *, double *, int *); +#endif + +int BLASFUNC(cdotuw) (int *, float *, int *, float *, int *, float*); +int BLASFUNC(cdotcw) (int *, float *, int *, float *, int *, float*); +int BLASFUNC(zdotuw) (int *, double *, int *, double *, int *, double*); +int BLASFUNC(zdotcw) (int *, double *, int *, double *, int *, double*); + +int BLASFUNC(saxpy) (int *, float *, float *, int *, float *, int *); +int BLASFUNC(daxpy) (int *, double *, double *, int *, double *, int *); +int BLASFUNC(qaxpy) (int *, double *, double *, int *, double *, int *); +int BLASFUNC(caxpy) (int *, float *, float *, int *, float *, int *); +int BLASFUNC(zaxpy) (int *, double *, double *, int *, double *, int *); +int BLASFUNC(xaxpy) (int *, double *, double *, int *, double *, int *); +int BLASFUNC(caxpyc)(int *, float *, float *, int *, float *, int *); +int BLASFUNC(zaxpyc)(int *, double *, double *, int *, double *, int *); +int BLASFUNC(xaxpyc)(int *, double *, double *, int *, double *, int *); + +int BLASFUNC(scopy) (int *, float *, int *, float *, int *); +int BLASFUNC(dcopy) (int *, double *, int *, double *, int *); +int BLASFUNC(qcopy) (int *, double *, int *, double *, int *); +int BLASFUNC(ccopy) (int *, float *, int *, float *, int *); +int BLASFUNC(zcopy) (int *, double *, int *, double *, int *); +int BLASFUNC(xcopy) (int *, double *, int *, double *, int *); + +int BLASFUNC(sswap) (int *, float *, int *, float *, int *); +int BLASFUNC(dswap) (int *, double *, int *, double *, int *); +int BLASFUNC(qswap) (int *, double *, int *, double *, int *); +int BLASFUNC(cswap) (int *, float *, int *, float *, int *); +int BLASFUNC(zswap) (int *, double *, int *, double *, int *); +int BLASFUNC(xswap) (int *, double *, int *, double *, int *); + +float BLASFUNC(sasum) (int *, float *, int *); +float BLASFUNC(scasum)(int *, float *, int *); +double BLASFUNC(dasum) (int *, double *, int *); +double BLASFUNC(qasum) (int *, double *, int *); +double BLASFUNC(dzasum)(int *, double *, int *); +double BLASFUNC(qxasum)(int *, double *, int *); + +int BLASFUNC(isamax)(int *, float *, int *); +int BLASFUNC(idamax)(int *, double *, int *); +int BLASFUNC(iqamax)(int *, double *, int *); +int BLASFUNC(icamax)(int *, float *, int *); +int BLASFUNC(izamax)(int *, double *, int *); +int BLASFUNC(ixamax)(int *, double *, int *); + +int BLASFUNC(ismax) (int *, float *, int *); +int BLASFUNC(idmax) (int *, double *, int *); +int BLASFUNC(iqmax) (int *, double *, int *); +int BLASFUNC(icmax) (int *, float *, int *); +int BLASFUNC(izmax) (int *, double *, int *); +int BLASFUNC(ixmax) (int *, double *, int *); + +int BLASFUNC(isamin)(int *, float *, int *); +int BLASFUNC(idamin)(int *, double *, int *); +int BLASFUNC(iqamin)(int *, double *, int *); +int BLASFUNC(icamin)(int *, float *, int *); +int BLASFUNC(izamin)(int *, double *, int *); +int BLASFUNC(ixamin)(int *, double *, int *); + +int BLASFUNC(ismin)(int *, float *, int *); +int BLASFUNC(idmin)(int *, double *, int *); +int BLASFUNC(iqmin)(int *, double *, int *); +int BLASFUNC(icmin)(int *, float *, int *); +int BLASFUNC(izmin)(int *, double *, int *); +int BLASFUNC(ixmin)(int *, double *, int *); + +float BLASFUNC(samax) (int *, float *, int *); +double BLASFUNC(damax) (int *, double *, int *); +double BLASFUNC(qamax) (int *, double *, int *); +float BLASFUNC(scamax)(int *, float *, int *); +double BLASFUNC(dzamax)(int *, double *, int *); +double BLASFUNC(qxamax)(int *, double *, int *); + +float BLASFUNC(samin) (int *, float *, int *); +double BLASFUNC(damin) (int *, double *, int *); +double BLASFUNC(qamin) (int *, double *, int *); +float BLASFUNC(scamin)(int *, float *, int *); +double BLASFUNC(dzamin)(int *, double *, int *); +double BLASFUNC(qxamin)(int *, double *, int *); + +float BLASFUNC(smax) (int *, float *, int *); +double BLASFUNC(dmax) (int *, double *, int *); +double BLASFUNC(qmax) (int *, double *, int *); +float BLASFUNC(scmax) (int *, float *, int *); +double BLASFUNC(dzmax) (int *, double *, int *); +double BLASFUNC(qxmax) (int *, double *, int *); + +float BLASFUNC(smin) (int *, float *, int *); +double BLASFUNC(dmin) (int *, double *, int *); +double BLASFUNC(qmin) (int *, double *, int *); +float BLASFUNC(scmin) (int *, float *, int *); +double BLASFUNC(dzmin) (int *, double *, int *); +double BLASFUNC(qxmin) (int *, double *, int *); + +int BLASFUNC(sscal) (int *, float *, float *, int *); +int BLASFUNC(dscal) (int *, double *, double *, int *); +int BLASFUNC(qscal) (int *, double *, double *, int *); +int BLASFUNC(cscal) (int *, float *, float *, int *); +int BLASFUNC(zscal) (int *, double *, double *, int *); +int BLASFUNC(xscal) (int *, double *, double *, int *); +int BLASFUNC(csscal)(int *, float *, float *, int *); +int BLASFUNC(zdscal)(int *, double *, double *, int *); +int BLASFUNC(xqscal)(int *, double *, double *, int *); + +float BLASFUNC(snrm2) (int *, float *, int *); +float BLASFUNC(scnrm2)(int *, float *, int *); + +double BLASFUNC(dnrm2) (int *, double *, int *); +double BLASFUNC(qnrm2) (int *, double *, int *); +double BLASFUNC(dznrm2)(int *, double *, int *); +double BLASFUNC(qxnrm2)(int *, double *, int *); + +int BLASFUNC(srot) (int *, float *, int *, float *, int *, float *, float *); +int BLASFUNC(drot) (int *, double *, int *, double *, int *, double *, double *); +int BLASFUNC(qrot) (int *, double *, int *, double *, int *, double *, double *); +int BLASFUNC(csrot) (int *, float *, int *, float *, int *, float *, float *); +int BLASFUNC(zdrot) (int *, double *, int *, double *, int *, double *, double *); +int BLASFUNC(xqrot) (int *, double *, int *, double *, int *, double *, double *); + +int BLASFUNC(srotg) (float *, float *, float *, float *); +int BLASFUNC(drotg) (double *, double *, double *, double *); +int BLASFUNC(qrotg) (double *, double *, double *, double *); +int BLASFUNC(crotg) (float *, float *, float *, float *); +int BLASFUNC(zrotg) (double *, double *, double *, double *); +int BLASFUNC(xrotg) (double *, double *, double *, double *); + +int BLASFUNC(srotmg)(float *, float *, float *, float *, float *); +int BLASFUNC(drotmg)(double *, double *, double *, double *, double *); + +int BLASFUNC(srotm) (int *, float *, int *, float *, int *, float *); +int BLASFUNC(drotm) (int *, double *, int *, double *, int *, double *); +int BLASFUNC(qrotm) (int *, double *, int *, double *, int *, double *); + +/* Level 2 routines */ + +int BLASFUNC(sger)(int *, int *, float *, float *, int *, + float *, int *, float *, int *); +int BLASFUNC(dger)(int *, int *, double *, double *, int *, + double *, int *, double *, int *); +int BLASFUNC(qger)(int *, int *, double *, double *, int *, + double *, int *, double *, int *); +int BLASFUNC(cgeru)(int *, int *, float *, float *, int *, + float *, int *, float *, int *); +int BLASFUNC(cgerc)(int *, int *, float *, float *, int *, + float *, int *, float *, int *); +int BLASFUNC(zgeru)(int *, int *, double *, double *, int *, + double *, int *, double *, int *); +int BLASFUNC(zgerc)(int *, int *, double *, double *, int *, + double *, int *, double *, int *); +int BLASFUNC(xgeru)(int *, int *, double *, double *, int *, + double *, int *, double *, int *); +int BLASFUNC(xgerc)(int *, int *, double *, double *, int *, + double *, int *, double *, int *); + +int BLASFUNC(sgemv)(char *, int *, int *, float *, float *, int *, + float *, int *, float *, float *, int *); +int BLASFUNC(dgemv)(char *, int *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); +int BLASFUNC(qgemv)(char *, int *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); +int BLASFUNC(cgemv)(char *, int *, int *, float *, float *, int *, + float *, int *, float *, float *, int *); +int BLASFUNC(zgemv)(char *, int *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); +int BLASFUNC(xgemv)(char *, int *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); + +int BLASFUNC(strsv) (char *, char *, char *, int *, float *, int *, + float *, int *); +int BLASFUNC(dtrsv) (char *, char *, char *, int *, double *, int *, + double *, int *); +int BLASFUNC(qtrsv) (char *, char *, char *, int *, double *, int *, + double *, int *); +int BLASFUNC(ctrsv) (char *, char *, char *, int *, float *, int *, + float *, int *); +int BLASFUNC(ztrsv) (char *, char *, char *, int *, double *, int *, + double *, int *); +int BLASFUNC(xtrsv) (char *, char *, char *, int *, double *, int *, + double *, int *); + +int BLASFUNC(stpsv) (char *, char *, char *, int *, float *, float *, int *); +int BLASFUNC(dtpsv) (char *, char *, char *, int *, double *, double *, int *); +int BLASFUNC(qtpsv) (char *, char *, char *, int *, double *, double *, int *); +int BLASFUNC(ctpsv) (char *, char *, char *, int *, float *, float *, int *); +int BLASFUNC(ztpsv) (char *, char *, char *, int *, double *, double *, int *); +int BLASFUNC(xtpsv) (char *, char *, char *, int *, double *, double *, int *); + +int BLASFUNC(strmv) (char *, char *, char *, int *, float *, int *, + float *, int *); +int BLASFUNC(dtrmv) (char *, char *, char *, int *, double *, int *, + double *, int *); +int BLASFUNC(qtrmv) (char *, char *, char *, int *, double *, int *, + double *, int *); +int BLASFUNC(ctrmv) (char *, char *, char *, int *, float *, int *, + float *, int *); +int BLASFUNC(ztrmv) (char *, char *, char *, int *, double *, int *, + double *, int *); +int BLASFUNC(xtrmv) (char *, char *, char *, int *, double *, int *, + double *, int *); + +int BLASFUNC(stpmv) (char *, char *, char *, int *, float *, float *, int *); +int BLASFUNC(dtpmv) (char *, char *, char *, int *, double *, double *, int *); +int BLASFUNC(qtpmv) (char *, char *, char *, int *, double *, double *, int *); +int BLASFUNC(ctpmv) (char *, char *, char *, int *, float *, float *, int *); +int BLASFUNC(ztpmv) (char *, char *, char *, int *, double *, double *, int *); +int BLASFUNC(xtpmv) (char *, char *, char *, int *, double *, double *, int *); + +int BLASFUNC(stbmv) (char *, char *, char *, int *, int *, float *, int *, float *, int *); +int BLASFUNC(dtbmv) (char *, char *, char *, int *, int *, double *, int *, double *, int *); +int BLASFUNC(qtbmv) (char *, char *, char *, int *, int *, double *, int *, double *, int *); +int BLASFUNC(ctbmv) (char *, char *, char *, int *, int *, float *, int *, float *, int *); +int BLASFUNC(ztbmv) (char *, char *, char *, int *, int *, double *, int *, double *, int *); +int BLASFUNC(xtbmv) (char *, char *, char *, int *, int *, double *, int *, double *, int *); + +int BLASFUNC(stbsv) (char *, char *, char *, int *, int *, float *, int *, float *, int *); +int BLASFUNC(dtbsv) (char *, char *, char *, int *, int *, double *, int *, double *, int *); +int BLASFUNC(qtbsv) (char *, char *, char *, int *, int *, double *, int *, double *, int *); +int BLASFUNC(ctbsv) (char *, char *, char *, int *, int *, float *, int *, float *, int *); +int BLASFUNC(ztbsv) (char *, char *, char *, int *, int *, double *, int *, double *, int *); +int BLASFUNC(xtbsv) (char *, char *, char *, int *, int *, double *, int *, double *, int *); + +int BLASFUNC(ssymv) (char *, int *, float *, float *, int *, + float *, int *, float *, float *, int *); +int BLASFUNC(dsymv) (char *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); +int BLASFUNC(qsymv) (char *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); +int BLASFUNC(csymv) (char *, int *, float *, float *, int *, + float *, int *, float *, float *, int *); +int BLASFUNC(zsymv) (char *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); +int BLASFUNC(xsymv) (char *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); + +int BLASFUNC(sspmv) (char *, int *, float *, float *, + float *, int *, float *, float *, int *); +int BLASFUNC(dspmv) (char *, int *, double *, double *, + double *, int *, double *, double *, int *); +int BLASFUNC(qspmv) (char *, int *, double *, double *, + double *, int *, double *, double *, int *); +int BLASFUNC(cspmv) (char *, int *, float *, float *, + float *, int *, float *, float *, int *); +int BLASFUNC(zspmv) (char *, int *, double *, double *, + double *, int *, double *, double *, int *); +int BLASFUNC(xspmv) (char *, int *, double *, double *, + double *, int *, double *, double *, int *); + +int BLASFUNC(ssyr) (char *, int *, float *, float *, int *, + float *, int *); +int BLASFUNC(dsyr) (char *, int *, double *, double *, int *, + double *, int *); +int BLASFUNC(qsyr) (char *, int *, double *, double *, int *, + double *, int *); +int BLASFUNC(csyr) (char *, int *, float *, float *, int *, + float *, int *); +int BLASFUNC(zsyr) (char *, int *, double *, double *, int *, + double *, int *); +int BLASFUNC(xsyr) (char *, int *, double *, double *, int *, + double *, int *); + +int BLASFUNC(ssyr2) (char *, int *, float *, + float *, int *, float *, int *, float *, int *); +int BLASFUNC(dsyr2) (char *, int *, double *, + double *, int *, double *, int *, double *, int *); +int BLASFUNC(qsyr2) (char *, int *, double *, + double *, int *, double *, int *, double *, int *); +int BLASFUNC(csyr2) (char *, int *, float *, + float *, int *, float *, int *, float *, int *); +int BLASFUNC(zsyr2) (char *, int *, double *, + double *, int *, double *, int *, double *, int *); +int BLASFUNC(xsyr2) (char *, int *, double *, + double *, int *, double *, int *, double *, int *); + +int BLASFUNC(sspr) (char *, int *, float *, float *, int *, + float *); +int BLASFUNC(dspr) (char *, int *, double *, double *, int *, + double *); +int BLASFUNC(qspr) (char *, int *, double *, double *, int *, + double *); +int BLASFUNC(cspr) (char *, int *, float *, float *, int *, + float *); +int BLASFUNC(zspr) (char *, int *, double *, double *, int *, + double *); +int BLASFUNC(xspr) (char *, int *, double *, double *, int *, + double *); + +int BLASFUNC(sspr2) (char *, int *, float *, + float *, int *, float *, int *, float *); +int BLASFUNC(dspr2) (char *, int *, double *, + double *, int *, double *, int *, double *); +int BLASFUNC(qspr2) (char *, int *, double *, + double *, int *, double *, int *, double *); +int BLASFUNC(cspr2) (char *, int *, float *, + float *, int *, float *, int *, float *); +int BLASFUNC(zspr2) (char *, int *, double *, + double *, int *, double *, int *, double *); +int BLASFUNC(xspr2) (char *, int *, double *, + double *, int *, double *, int *, double *); + +int BLASFUNC(cher) (char *, int *, float *, float *, int *, + float *, int *); +int BLASFUNC(zher) (char *, int *, double *, double *, int *, + double *, int *); +int BLASFUNC(xher) (char *, int *, double *, double *, int *, + double *, int *); + +int BLASFUNC(chpr) (char *, int *, float *, float *, int *, float *); +int BLASFUNC(zhpr) (char *, int *, double *, double *, int *, double *); +int BLASFUNC(xhpr) (char *, int *, double *, double *, int *, double *); + +int BLASFUNC(cher2) (char *, int *, float *, + float *, int *, float *, int *, float *, int *); +int BLASFUNC(zher2) (char *, int *, double *, + double *, int *, double *, int *, double *, int *); +int BLASFUNC(xher2) (char *, int *, double *, + double *, int *, double *, int *, double *, int *); + +int BLASFUNC(chpr2) (char *, int *, float *, + float *, int *, float *, int *, float *); +int BLASFUNC(zhpr2) (char *, int *, double *, + double *, int *, double *, int *, double *); +int BLASFUNC(xhpr2) (char *, int *, double *, + double *, int *, double *, int *, double *); + +int BLASFUNC(chemv) (char *, int *, float *, float *, int *, + float *, int *, float *, float *, int *); +int BLASFUNC(zhemv) (char *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); +int BLASFUNC(xhemv) (char *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); + +int BLASFUNC(chpmv) (char *, int *, float *, float *, + float *, int *, float *, float *, int *); +int BLASFUNC(zhpmv) (char *, int *, double *, double *, + double *, int *, double *, double *, int *); +int BLASFUNC(xhpmv) (char *, int *, double *, double *, + double *, int *, double *, double *, int *); + +int BLASFUNC(snorm)(char *, int *, int *, float *, int *); +int BLASFUNC(dnorm)(char *, int *, int *, double *, int *); +int BLASFUNC(cnorm)(char *, int *, int *, float *, int *); +int BLASFUNC(znorm)(char *, int *, int *, double *, int *); + +int BLASFUNC(sgbmv)(char *, int *, int *, int *, int *, float *, float *, int *, + float *, int *, float *, float *, int *); +int BLASFUNC(dgbmv)(char *, int *, int *, int *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); +int BLASFUNC(qgbmv)(char *, int *, int *, int *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); +int BLASFUNC(cgbmv)(char *, int *, int *, int *, int *, float *, float *, int *, + float *, int *, float *, float *, int *); +int BLASFUNC(zgbmv)(char *, int *, int *, int *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); +int BLASFUNC(xgbmv)(char *, int *, int *, int *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); + +int BLASFUNC(ssbmv)(char *, int *, int *, float *, float *, int *, + float *, int *, float *, float *, int *); +int BLASFUNC(dsbmv)(char *, int *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); +int BLASFUNC(qsbmv)(char *, int *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); +int BLASFUNC(csbmv)(char *, int *, int *, float *, float *, int *, + float *, int *, float *, float *, int *); +int BLASFUNC(zsbmv)(char *, int *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); +int BLASFUNC(xsbmv)(char *, int *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); + +int BLASFUNC(chbmv)(char *, int *, int *, float *, float *, int *, + float *, int *, float *, float *, int *); +int BLASFUNC(zhbmv)(char *, int *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); +int BLASFUNC(xhbmv)(char *, int *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); + +/* Level 3 routines */ + +int BLASFUNC(sgemm)(char *, char *, int *, int *, int *, float *, + float *, int *, float *, int *, float *, float *, int *); +int BLASFUNC(dgemm)(char *, char *, int *, int *, int *, double *, + double *, int *, double *, int *, double *, double *, int *); +int BLASFUNC(qgemm)(char *, char *, int *, int *, int *, double *, + double *, int *, double *, int *, double *, double *, int *); +int BLASFUNC(cgemm)(char *, char *, int *, int *, int *, float *, + float *, int *, float *, int *, float *, float *, int *); +int BLASFUNC(zgemm)(char *, char *, int *, int *, int *, double *, + double *, int *, double *, int *, double *, double *, int *); +int BLASFUNC(xgemm)(char *, char *, int *, int *, int *, double *, + double *, int *, double *, int *, double *, double *, int *); + +int BLASFUNC(cgemm3m)(char *, char *, int *, int *, int *, float *, + float *, int *, float *, int *, float *, float *, int *); +int BLASFUNC(zgemm3m)(char *, char *, int *, int *, int *, double *, + double *, int *, double *, int *, double *, double *, int *); +int BLASFUNC(xgemm3m)(char *, char *, int *, int *, int *, double *, + double *, int *, double *, int *, double *, double *, int *); + +int BLASFUNC(sge2mm)(char *, char *, char *, int *, int *, + float *, float *, int *, float *, int *, + float *, float *, int *); +int BLASFUNC(dge2mm)(char *, char *, char *, int *, int *, + double *, double *, int *, double *, int *, + double *, double *, int *); +int BLASFUNC(cge2mm)(char *, char *, char *, int *, int *, + float *, float *, int *, float *, int *, + float *, float *, int *); +int BLASFUNC(zge2mm)(char *, char *, char *, int *, int *, + double *, double *, int *, double *, int *, + double *, double *, int *); + +int BLASFUNC(strsm)(char *, char *, char *, char *, int *, int *, + float *, float *, int *, float *, int *); +int BLASFUNC(dtrsm)(char *, char *, char *, char *, int *, int *, + double *, double *, int *, double *, int *); +int BLASFUNC(qtrsm)(char *, char *, char *, char *, int *, int *, + double *, double *, int *, double *, int *); +int BLASFUNC(ctrsm)(char *, char *, char *, char *, int *, int *, + float *, float *, int *, float *, int *); +int BLASFUNC(ztrsm)(char *, char *, char *, char *, int *, int *, + double *, double *, int *, double *, int *); +int BLASFUNC(xtrsm)(char *, char *, char *, char *, int *, int *, + double *, double *, int *, double *, int *); + +int BLASFUNC(strmm)(char *, char *, char *, char *, int *, int *, + float *, float *, int *, float *, int *); +int BLASFUNC(dtrmm)(char *, char *, char *, char *, int *, int *, + double *, double *, int *, double *, int *); +int BLASFUNC(qtrmm)(char *, char *, char *, char *, int *, int *, + double *, double *, int *, double *, int *); +int BLASFUNC(ctrmm)(char *, char *, char *, char *, int *, int *, + float *, float *, int *, float *, int *); +int BLASFUNC(ztrmm)(char *, char *, char *, char *, int *, int *, + double *, double *, int *, double *, int *); +int BLASFUNC(xtrmm)(char *, char *, char *, char *, int *, int *, + double *, double *, int *, double *, int *); + +int BLASFUNC(ssymm)(char *, char *, int *, int *, float *, float *, int *, + float *, int *, float *, float *, int *); +int BLASFUNC(dsymm)(char *, char *, int *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); +int BLASFUNC(qsymm)(char *, char *, int *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); +int BLASFUNC(csymm)(char *, char *, int *, int *, float *, float *, int *, + float *, int *, float *, float *, int *); +int BLASFUNC(zsymm)(char *, char *, int *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); +int BLASFUNC(xsymm)(char *, char *, int *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); + +int BLASFUNC(csymm3m)(char *, char *, int *, int *, float *, float *, int *, + float *, int *, float *, float *, int *); +int BLASFUNC(zsymm3m)(char *, char *, int *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); +int BLASFUNC(xsymm3m)(char *, char *, int *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); + +int BLASFUNC(ssyrk)(char *, char *, int *, int *, float *, float *, int *, + float *, float *, int *); +int BLASFUNC(dsyrk)(char *, char *, int *, int *, double *, double *, int *, + double *, double *, int *); +int BLASFUNC(qsyrk)(char *, char *, int *, int *, double *, double *, int *, + double *, double *, int *); +int BLASFUNC(csyrk)(char *, char *, int *, int *, float *, float *, int *, + float *, float *, int *); +int BLASFUNC(zsyrk)(char *, char *, int *, int *, double *, double *, int *, + double *, double *, int *); +int BLASFUNC(xsyrk)(char *, char *, int *, int *, double *, double *, int *, + double *, double *, int *); + +int BLASFUNC(ssyr2k)(char *, char *, int *, int *, float *, float *, int *, + float *, int *, float *, float *, int *); +int BLASFUNC(dsyr2k)(char *, char *, int *, int *, double *, double *, int *, + double*, int *, double *, double *, int *); +int BLASFUNC(qsyr2k)(char *, char *, int *, int *, double *, double *, int *, + double*, int *, double *, double *, int *); +int BLASFUNC(csyr2k)(char *, char *, int *, int *, float *, float *, int *, + float *, int *, float *, float *, int *); +int BLASFUNC(zsyr2k)(char *, char *, int *, int *, double *, double *, int *, + double*, int *, double *, double *, int *); +int BLASFUNC(xsyr2k)(char *, char *, int *, int *, double *, double *, int *, + double*, int *, double *, double *, int *); + +int BLASFUNC(chemm)(char *, char *, int *, int *, float *, float *, int *, + float *, int *, float *, float *, int *); +int BLASFUNC(zhemm)(char *, char *, int *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); +int BLASFUNC(xhemm)(char *, char *, int *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); + +int BLASFUNC(chemm3m)(char *, char *, int *, int *, float *, float *, int *, + float *, int *, float *, float *, int *); +int BLASFUNC(zhemm3m)(char *, char *, int *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); +int BLASFUNC(xhemm3m)(char *, char *, int *, int *, double *, double *, int *, + double *, int *, double *, double *, int *); + +int BLASFUNC(cherk)(char *, char *, int *, int *, float *, float *, int *, + float *, float *, int *); +int BLASFUNC(zherk)(char *, char *, int *, int *, double *, double *, int *, + double *, double *, int *); +int BLASFUNC(xherk)(char *, char *, int *, int *, double *, double *, int *, + double *, double *, int *); + +int BLASFUNC(cher2k)(char *, char *, int *, int *, float *, float *, int *, + float *, int *, float *, float *, int *); +int BLASFUNC(zher2k)(char *, char *, int *, int *, double *, double *, int *, + double*, int *, double *, double *, int *); +int BLASFUNC(xher2k)(char *, char *, int *, int *, double *, double *, int *, + double*, int *, double *, double *, int *); +int BLASFUNC(cher2m)(char *, char *, char *, int *, int *, float *, float *, int *, + float *, int *, float *, float *, int *); +int BLASFUNC(zher2m)(char *, char *, char *, int *, int *, double *, double *, int *, + double*, int *, double *, double *, int *); +int BLASFUNC(xher2m)(char *, char *, char *, int *, int *, double *, double *, int *, + double*, int *, double *, double *, int *); + +int BLASFUNC(sgemt)(char *, int *, int *, float *, float *, int *, + float *, int *); +int BLASFUNC(dgemt)(char *, int *, int *, double *, double *, int *, + double *, int *); +int BLASFUNC(cgemt)(char *, int *, int *, float *, float *, int *, + float *, int *); +int BLASFUNC(zgemt)(char *, int *, int *, double *, double *, int *, + double *, int *); + +int BLASFUNC(sgema)(char *, char *, int *, int *, float *, + float *, int *, float *, float *, int *, float *, int *); +int BLASFUNC(dgema)(char *, char *, int *, int *, double *, + double *, int *, double*, double *, int *, double*, int *); +int BLASFUNC(cgema)(char *, char *, int *, int *, float *, + float *, int *, float *, float *, int *, float *, int *); +int BLASFUNC(zgema)(char *, char *, int *, int *, double *, + double *, int *, double*, double *, int *, double*, int *); + +int BLASFUNC(sgems)(char *, char *, int *, int *, float *, + float *, int *, float *, float *, int *, float *, int *); +int BLASFUNC(dgems)(char *, char *, int *, int *, double *, + double *, int *, double*, double *, int *, double*, int *); +int BLASFUNC(cgems)(char *, char *, int *, int *, float *, + float *, int *, float *, float *, int *, float *, int *); +int BLASFUNC(zgems)(char *, char *, int *, int *, double *, + double *, int *, double*, double *, int *, double*, int *); + +int BLASFUNC(sgetf2)(int *, int *, float *, int *, int *, int *); +int BLASFUNC(dgetf2)(int *, int *, double *, int *, int *, int *); +int BLASFUNC(qgetf2)(int *, int *, double *, int *, int *, int *); +int BLASFUNC(cgetf2)(int *, int *, float *, int *, int *, int *); +int BLASFUNC(zgetf2)(int *, int *, double *, int *, int *, int *); +int BLASFUNC(xgetf2)(int *, int *, double *, int *, int *, int *); + +//int BLASFUNC(sgetrf)(int *, int *, float *, int *, int *, int *); +//int BLASFUNC(dgetrf)(int *, int *, double *, int *, int *, int *); +int BLASFUNC(qgetrf)(int *, int *, double *, int *, int *, int *); +int BLASFUNC(cgetrf)(int *, int *, float *, int *, int *, int *); +int BLASFUNC(zgetrf)(int *, int *, double *, int *, int *, int *); +int BLASFUNC(xgetrf)(int *, int *, double *, int *, int *, int *); + +int BLASFUNC(slaswp)(int *, float *, int *, int *, int *, int *, int *); +int BLASFUNC(dlaswp)(int *, double *, int *, int *, int *, int *, int *); +int BLASFUNC(qlaswp)(int *, double *, int *, int *, int *, int *, int *); +int BLASFUNC(claswp)(int *, float *, int *, int *, int *, int *, int *); +int BLASFUNC(zlaswp)(int *, double *, int *, int *, int *, int *, int *); +int BLASFUNC(xlaswp)(int *, double *, int *, int *, int *, int *, int *); + +int BLASFUNC(sgetrs)(char *, int *, int *, float *, int *, int *, float *, int *, int *); +int BLASFUNC(dgetrs)(char *, int *, int *, double *, int *, int *, double *, int *, int *); +int BLASFUNC(qgetrs)(char *, int *, int *, double *, int *, int *, double *, int *, int *); +int BLASFUNC(cgetrs)(char *, int *, int *, float *, int *, int *, float *, int *, int *); +int BLASFUNC(zgetrs)(char *, int *, int *, double *, int *, int *, double *, int *, int *); +int BLASFUNC(xgetrs)(char *, int *, int *, double *, int *, int *, double *, int *, int *); + +int BLASFUNC(sgesv)(int *, int *, float *, int *, int *, float *, int *, int *); +int BLASFUNC(dgesv)(int *, int *, double *, int *, int *, double*, int *, int *); +int BLASFUNC(qgesv)(int *, int *, double *, int *, int *, double*, int *, int *); +int BLASFUNC(cgesv)(int *, int *, float *, int *, int *, float *, int *, int *); +int BLASFUNC(zgesv)(int *, int *, double *, int *, int *, double*, int *, int *); +int BLASFUNC(xgesv)(int *, int *, double *, int *, int *, double*, int *, int *); + +int BLASFUNC(spotf2)(char *, int *, float *, int *, int *); +int BLASFUNC(dpotf2)(char *, int *, double *, int *, int *); +int BLASFUNC(qpotf2)(char *, int *, double *, int *, int *); +int BLASFUNC(cpotf2)(char *, int *, float *, int *, int *); +int BLASFUNC(zpotf2)(char *, int *, double *, int *, int *); +int BLASFUNC(xpotf2)(char *, int *, double *, int *, int *); + +//int BLASFUNC(spotrf)(char *, int *, float *, int *, int *); +//int BLASFUNC(dpotrf)(char *, int *, double *, int *, int *); +int BLASFUNC(qpotrf)(char *, int *, double *, int *, int *); +int BLASFUNC(cpotrf)(char *, int *, float *, int *, int *); +int BLASFUNC(zpotrf)(char *, int *, double *, int *, int *); +int BLASFUNC(xpotrf)(char *, int *, double *, int *, int *); + +int BLASFUNC(slauu2)(char *, int *, float *, int *, int *); +int BLASFUNC(dlauu2)(char *, int *, double *, int *, int *); +int BLASFUNC(qlauu2)(char *, int *, double *, int *, int *); +int BLASFUNC(clauu2)(char *, int *, float *, int *, int *); +int BLASFUNC(zlauu2)(char *, int *, double *, int *, int *); +int BLASFUNC(xlauu2)(char *, int *, double *, int *, int *); + +int BLASFUNC(slauum)(char *, int *, float *, int *, int *); +int BLASFUNC(dlauum)(char *, int *, double *, int *, int *); +int BLASFUNC(qlauum)(char *, int *, double *, int *, int *); +int BLASFUNC(clauum)(char *, int *, float *, int *, int *); +int BLASFUNC(zlauum)(char *, int *, double *, int *, int *); +int BLASFUNC(xlauum)(char *, int *, double *, int *, int *); + +int BLASFUNC(strti2)(char *, char *, int *, float *, int *, int *); +int BLASFUNC(dtrti2)(char *, char *, int *, double *, int *, int *); +int BLASFUNC(qtrti2)(char *, char *, int *, double *, int *, int *); +int BLASFUNC(ctrti2)(char *, char *, int *, float *, int *, int *); +int BLASFUNC(ztrti2)(char *, char *, int *, double *, int *, int *); +int BLASFUNC(xtrti2)(char *, char *, int *, double *, int *, int *); + +int BLASFUNC(strtri)(char *, char *, int *, float *, int *, int *); +int BLASFUNC(dtrtri)(char *, char *, int *, double *, int *, int *); +int BLASFUNC(qtrtri)(char *, char *, int *, double *, int *, int *); +int BLASFUNC(ctrtri)(char *, char *, int *, float *, int *, int *); +int BLASFUNC(ztrtri)(char *, char *, int *, double *, int *, int *); +int BLASFUNC(xtrtri)(char *, char *, int *, double *, int *, int *); + +int BLASFUNC(spotri)(char *, int *, float *, int *, int *); +int BLASFUNC(dpotri)(char *, int *, double *, int *, int *); +int BLASFUNC(qpotri)(char *, int *, double *, int *, int *); +int BLASFUNC(cpotri)(char *, int *, float *, int *, int *); +int BLASFUNC(zpotri)(char *, int *, double *, int *, int *); +int BLASFUNC(xpotri)(char *, int *, double *, int *, int *); + +} + +#endif diff --git a/btl/libs/BLAS/blas_interface.hh b/btl/libs/BLAS/blas_interface.hh new file mode 100644 index 0000000..19fc3c1 --- /dev/null +++ b/btl/libs/BLAS/blas_interface.hh @@ -0,0 +1,77 @@ +//===================================================== +// File : blas_interface.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, lun sep 30 14:23:28 CEST 2002 +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef blas_PRODUIT_MATRICE_VECTEUR_HH +#define blas_PRODUIT_MATRICE_VECTEUR_HH + +#include <c_interface_base.h> +#include <complex> +extern "C" +{ +#include "blas.h" +#ifdef CBLAS_INTERFACE +# include "cblas.h" +#endif +} + +#define MAKE_STRING2(S) #S +#define MAKE_STRING(S) MAKE_STRING2(S) + +#define CAT2(A,B) A##B +#define CAT(A,B) CAT2(A,B) + + +template<class real> class blas_interface; + + +static char notrans = 'N'; +static char trans = 'T'; +static char nonunit = 'N'; +static char lower = 'L'; +static char right = 'R'; +static char left = 'L'; +static int intone = 1; + + +#define SCALAR float +#define SCALAR_PREFIX s +#ifdef CBLAS_INTERFACE +# include "cblas_interface_impl.hh" +#else +# include "blas_interface_impl.hh" +#endif +#undef SCALAR +#undef SCALAR_PREFIX + + +#define SCALAR double +#define SCALAR_PREFIX d +#ifdef CBLAS_INTERFACE +# include "cblas_interface_impl.hh" +#else +# include "blas_interface_impl.hh" +#endif +#undef SCALAR +#undef SCALAR_PREFIX + +#endif + + + diff --git a/btl/libs/BLAS/blas_interface_impl.hh b/btl/libs/BLAS/blas_interface_impl.hh new file mode 100644 index 0000000..63883a9 --- /dev/null +++ b/btl/libs/BLAS/blas_interface_impl.hh @@ -0,0 +1,96 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// + +#define BLAS_FUNC(NAME) CAT(CAT(SCALAR_PREFIX,NAME),_) + +template<> class blas_interface<SCALAR> : public c_interface_base<SCALAR> +{ + +public : + + static SCALAR fone; + static SCALAR fzero; + + static inline std::string name() + { + return MAKE_STRING(CBLASNAME); + } + + static inline void matrix_vector_product(gene_matrix & A, gene_vector & B, gene_vector & X, int N){ + BLAS_FUNC(gemv)(¬rans,&N,&N,&fone,A,&N,B,&intone,&fzero,X,&intone); + } + + static inline void symv(gene_matrix & A, gene_vector & B, gene_vector & X, int N){ + BLAS_FUNC(symv)(&lower, &N,&fone,A,&N,B,&intone,&fzero,X,&intone); + } + + static inline void syr2(gene_matrix & A, gene_vector & B, gene_vector & X, int N){ + BLAS_FUNC(syr2)(&lower,&N,&fone,B,&intone,X,&intone,A,&N); + } + + static inline void ger(gene_matrix & A, gene_vector & X, gene_vector & Y, int N){ + BLAS_FUNC(ger)(&N,&N,&fone,X,&intone,Y,&intone,A,&N); + } + + static inline void rot(gene_vector & A, gene_vector & B, SCALAR c, SCALAR s, int N){ + BLAS_FUNC(rot)(&N,A,&intone,B,&intone,&c,&s); + } + + static inline void atv_product(gene_matrix & A, gene_vector & B, gene_vector & X, int N){ + BLAS_FUNC(gemv)(&trans,&N,&N,&fone,A,&N,B,&intone,&fzero,X,&intone); + } + + static inline void matrix_matrix_product(gene_matrix & A, gene_matrix & B, gene_matrix & X, int N){ + BLAS_FUNC(gemm)(¬rans,¬rans,&N,&N,&N,&fone,A,&N,B,&N,&fzero,X,&N); + } + + static inline void transposed_matrix_matrix_product(gene_matrix & A, gene_matrix & B, gene_matrix & X, int N){ + BLAS_FUNC(gemm)(¬rans,¬rans,&N,&N,&N,&fone,A,&N,B,&N,&fzero,X,&N); + } + + static inline void aat_product(gene_matrix & A, gene_matrix & X, int N){ + BLAS_FUNC(syrk)(&lower,¬rans,&N,&N,&fone,A,&N,&fzero,X,&N); + } + + static inline void axpy(SCALAR coef, const gene_vector & X, gene_vector & Y, int N){ + BLAS_FUNC(axpy)(&N,&coef,X,&intone,Y,&intone); + } + + static inline void axpby(SCALAR a, const gene_vector & X, SCALAR b, gene_vector & Y, int N){ + BLAS_FUNC(scal)(&N,&b,Y,&intone); + BLAS_FUNC(axpy)(&N,&a,X,&intone,Y,&intone); + } + + static inline void trisolve_lower(const gene_matrix & L, const gene_vector& B, gene_vector & X, int N){ + BLAS_FUNC(copy)(&N, B, &intone, X, &intone); + BLAS_FUNC(trsv)(&lower, ¬rans, &nonunit, &N, L, &N, X, &intone); + } + + static inline void trisolve_lower_matrix(const gene_matrix & L, const gene_matrix& B, gene_matrix & X, int N){ + BLAS_FUNC(copy)(&N, B, &intone, X, &intone); + BLAS_FUNC(trsm)(&right, &lower, ¬rans, &nonunit, &N, &N, &fone, L, &N, X, &N); + } + + static inline void trmm(gene_matrix & A, gene_matrix & B, gene_matrix & X, int N){ + BLAS_FUNC(trmm)(&left, &lower, ¬rans,&nonunit, &N,&N,&fone,A,&N,B,&N); + } + +}; + +SCALAR blas_interface<SCALAR>::fone = SCALAR(1); +SCALAR blas_interface<SCALAR>::fzero = SCALAR(0); diff --git a/btl/libs/BLAS/c_interface_base.h b/btl/libs/BLAS/c_interface_base.h new file mode 100644 index 0000000..3b6afbb --- /dev/null +++ b/btl/libs/BLAS/c_interface_base.h @@ -0,0 +1,89 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef BTL_C_INTERFACE_BASE_H +#define BTL_C_INTERFACE_BASE_H + +#include "utilities.h" +#include <vector> + +template<class real> class c_interface_base +{ + +public: + + typedef real real_type; + typedef std::vector<real> stl_vector; + typedef std::vector<stl_vector > stl_matrix; + + typedef real* gene_matrix; + typedef real* gene_vector; + + static void free_matrix(gene_matrix & A, int N){ + delete A; + } + + static void free_vector(gene_vector & B){ + delete B; + } + + static inline void matrix_from_stl(gene_matrix & A, stl_matrix & A_stl){ + int N = A_stl.size(); + A = new real[N*N]; + for (int j=0;j<N;j++) + for (int i=0;i<N;i++) + A[i+N*j] = A_stl[j][i]; + } + + static inline void vector_from_stl(gene_vector & B, stl_vector & B_stl){ + int N = B_stl.size(); + B = new real[N]; + for (int i=0;i<N;i++) + B[i] = B_stl[i]; + } + + static inline void vector_to_stl(gene_vector & B, stl_vector & B_stl){ + int N = B_stl.size(); + for (int i=0;i<N;i++) + B_stl[i] = B[i]; + } + + static inline void matrix_to_stl(gene_matrix & A, stl_matrix & A_stl){ + int N = A_stl.size(); + for (int j=0;j<N;j++){ + A_stl[j].resize(N); + for (int i=0;i<N;i++) + A_stl[j][i] = A[i+N*j]; + } + } + + static inline void copy_vector(const gene_vector & source, gene_vector & cible, int N){ + for (int i=0;i<N;i++) + cible[i]=source[i]; + } + + static inline void copy_matrix(const gene_matrix & source, gene_matrix & cible, int N){ + for (int j=0;j<N;j++){ + for (int i=0;i<N;i++){ + cible[i+N*j] = source[i+N*j]; + } + } + } + +}; + +#endif diff --git a/btl/libs/BLAS/cblas_interface_impl.hh b/btl/libs/BLAS/cblas_interface_impl.hh new file mode 100644 index 0000000..2da195e --- /dev/null +++ b/btl/libs/BLAS/cblas_interface_impl.hh @@ -0,0 +1,96 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// + +#define BLAS_FUNC(NAME) CAT(cblas_,CAT(SCALAR_PREFIX,NAME)) + +template<> class blas_interface<SCALAR> : public c_interface_base<SCALAR> +{ + +public : + + static SCALAR fone; + static SCALAR fzero; + + static inline std::string name() + { + return MAKE_STRING(CBLASNAME); + } + + static inline void matrix_vector_product(gene_matrix & A, gene_vector & B, gene_vector & X, int N){ + BLAS_FUNC(gemv)(CblasColMajor,CblasNoTrans,N,N,fone,A,N,B,intone,fzero,X,intone); + } + + static inline void symv(gene_matrix & A, gene_vector & B, gene_vector & X, int N){ + BLAS_FUNC(symv)(CblasColMajor,CblasLower,N,fone,A,N,B,intone,fzero,X,intone); + } + + static inline void syr2(gene_matrix & A, gene_vector & B, gene_vector & X, int N){ + BLAS_FUNC(syr2)(CblasColMajor,CblasLower,N,fone,B,intone,X,intone,A,N); + } + + static inline void ger(gene_matrix & A, gene_vector & X, gene_vector & Y, int N){ + BLAS_FUNC(ger)(CblasColMajor,N,N,fone,X,intone,Y,intone,A,N); + } + + static inline void rot(gene_vector & A, gene_vector & B, SCALAR c, SCALAR s, int N){ + BLAS_FUNC(rot)(N,A,intone,B,intone,c,s); + } + + static inline void atv_product(gene_matrix & A, gene_vector & B, gene_vector & X, int N){ + BLAS_FUNC(gemv)(CblasColMajor,CblasTrans,N,N,fone,A,N,B,intone,fzero,X,intone); + } + + static inline void matrix_matrix_product(gene_matrix & A, gene_matrix & B, gene_matrix & X, int N){ + BLAS_FUNC(gemm)(CblasColMajor,CblasNoTrans,CblasNoTrans,N,N,N,fone,A,N,B,N,fzero,X,N); + } + + static inline void transposed_matrix_matrix_product(gene_matrix & A, gene_matrix & B, gene_matrix & X, int N){ + BLAS_FUNC(gemm)(CblasColMajor,CblasTrans,CblasNoTrans,N,N,N,fone,A,N,B,N,fzero,X,N); + } + + static inline void aat_product(gene_matrix & A, gene_matrix & X, int N){ + BLAS_FUNC(syrk)(CblasColMajor,CblasLower,CblasNoTrans,N,N,fone,A,N,fzero,X,N); + } + + static inline void axpy(SCALAR coef, const gene_vector & X, gene_vector & Y, int N){ + BLAS_FUNC(axpy)(N,coef,X,intone,Y,intone); + } + + static inline void axpby(SCALAR a, const gene_vector & X, SCALAR b, gene_vector & Y, int N){ + BLAS_FUNC(scal)(N,b,Y,intone); + BLAS_FUNC(axpy)(N,a,X,intone,Y,intone); + } + + static inline void trisolve_lower(const gene_matrix & L, const gene_vector& B, gene_vector & X, int N){ + BLAS_FUNC(copy)(N, B, intone, X, intone); + BLAS_FUNC(trsv)(CblasColMajor,CblasLower, CblasNoTrans, CblasNonUnit, N, L, N, X, intone); + } + + static inline void trisolve_lower_matrix(const gene_matrix & L, const gene_matrix& B, gene_matrix & X, int N){ + BLAS_FUNC(copy)(N, B, intone, X, intone); + BLAS_FUNC(trsm)(CblasColMajor,CblasRight, CblasLower, CblasNoTrans, CblasNonUnit, N, N, fone, L, N, X, N); + } + + static inline void trmm(gene_matrix & A, gene_matrix & B, gene_matrix & X, int N){ + BLAS_FUNC(trmm)(CblasColMajor,CblasLeft, CblasLower, CblasNoTrans,CblasNonUnit, N,N,fone,A,N,B,N); + } + +}; + +SCALAR blas_interface<SCALAR>::fone = SCALAR(1); +SCALAR blas_interface<SCALAR>::fzero = SCALAR(0); diff --git a/btl/libs/BLAS/main.cpp b/btl/libs/BLAS/main.cpp new file mode 100644 index 0000000..401cb5b --- /dev/null +++ b/btl/libs/BLAS/main.cpp @@ -0,0 +1,116 @@ +//===================================================== +// File : main.cpp +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, lun sep 30 14:23:28 CEST 2002 +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// + +#ifndef BLAS_INTERFACE +# ifndef CBLAS_INTERFACE +# define BLAS_INTERFACE +# endif +#endif + +#include "utilities.h" +#include "blas_interface.hh" +#include "bench.hh" +#include "basic_actions.hh" +#include "action_trisolve_matrix.hh" + +#include <string> + +BTL_MAIN; + +int main(int argv, char **argc) +{ + bool + axpy=false, axpby=false, rot=false, + matrix_vector=false, atv=false, symv=false, syr2=false, ger=false, trisolve_vector=false, + matrix_matrix=false, aat=false, trisolve_matrix=false, trmm=false + ; + int N = 100; + + + for (int i = 1; i < argv; ++i) { + std::string arg = argc[i]; + if (arg == "axpy") axpy = true; + else if (arg == "axpby") axpby = true; + else if (arg == "rot") rot = true; + else if (arg == "matrix_vector") matrix_vector = true; + else if (arg == "atv") atv = true; + else if (arg == "symv") symv = true; + else if (arg == "syr2") syr2 = true; + else if (arg == "ger") ger = true; + else if (arg == "trisolve_vector") trisolve_vector = true; + else if (arg == "matrix_matrix") matrix_matrix = true; + else if (arg == "aat") aat = true; + else if (arg == "trisolve_matrix") trisolve_matrix = true; + else if (arg == "trmm") trmm = true; + + else if (arg[0] == '1' && arg[1] == '\0') { + axpy = true; axpby = true; rot = true; + } + else if (arg[0] == '2' && arg[1] == '\0') { + matrix_vector=true; atv=true; symv=true; syr2=true; ger=true; trisolve_vector=true; + } + else if (arg[0] == '3' && arg[1] == '\0') { + matrix_matrix=true; aat=true; trisolve_matrix=true; trmm=true; + } + + // Check switch -N + else if (arg[0] == '-' && arg[1] == 'N') { + if (arg[2] != '\0') + N = atoi(arg.c_str()+2); + else + N = atoi(argc[++i]); + } + } + + if (axpy) + bench<Action_axpy<blas_interface<REAL_TYPE> > >(MIN_AXPY,MAX_AXPY, N); + if (axpby) + bench<Action_axpby<blas_interface<REAL_TYPE> > >(MIN_AXPY,MAX_AXPY, N); + if (rot) + bench<Action_rot<blas_interface<REAL_TYPE> > >(MIN_AXPY,MAX_AXPY, N); + + if (matrix_vector) + bench<Action_matrix_vector_product<blas_interface<REAL_TYPE> > >(MIN_MV,MAX_MV, N); + if (atv) + bench<Action_atv_product<blas_interface<REAL_TYPE> > >(MIN_MV,MAX_MV, N); + if (symv) + bench<Action_symv<blas_interface<REAL_TYPE> > >(MIN_MV,MAX_MV, N); + if (syr2) + bench<Action_syr2<blas_interface<REAL_TYPE> > >(MIN_MV,MAX_MV, N); + if (ger) + bench<Action_ger<blas_interface<REAL_TYPE> > >(MIN_MV,MAX_MV, N); + if (trisolve_vector) + bench<Action_trisolve<blas_interface<REAL_TYPE> > >(MIN_MM,MAX_MM, N); + + if (matrix_matrix) + bench<Action_matrix_matrix_product<blas_interface<REAL_TYPE> > >(MIN_MM,MAX_MM, N); + if (aat) + bench<Action_aat_product<blas_interface<REAL_TYPE> > >(MIN_MM,MAX_MM, N); + if (trisolve_matrix) + bench<Action_trisolve_matrix<blas_interface<REAL_TYPE> > >(MIN_MM,MAX_MM, N); + if (trmm) + bench<Action_trmm<blas_interface<REAL_TYPE> > >(MIN_MM,MAX_MM, N); + + + return 0; +} + + diff --git a/btl/libs/FFTW/fftw_interface.hh b/btl/libs/FFTW/fftw_interface.hh new file mode 100644 index 0000000..81701e7 --- /dev/null +++ b/btl/libs/FFTW/fftw_interface.hh @@ -0,0 +1,87 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef BTL_FFTW_INTERFACE_H +#define BTL_FFTW_INTERFACE_H + +#include <complex> +#include <fftw3.h> +#include <vector> + +class fftw_interface +{ +public: + + static inline std::string name() + { + return std::string("fftw"); + } + + typedef std::complex<double> real_type; + typedef std::vector<std::complex<double> > stl_vector; + + typedef fftw_complex* gene_vector; + + typedef fftw_plan plan; + + static inline void free_vector(gene_vector & B){ + fftw_free(B); + } + + static inline void vector_from_stl(gene_vector & B, stl_vector & B_stl){ + int N = B_stl.size(); + B = (gene_vector) fftw_malloc(sizeof(fftw_complex) * N); + std::complex<double>* B_cplx = reinterpret_cast<std::complex<double>* >(B); + + for (int i=0;i<N;i++) + B_cplx[i] = B_stl[i]; + } + + static inline void vector_to_stl(gene_vector & B, stl_vector & B_stl){ + int N = B_stl.size(); + std::complex<double>* B_cplx = reinterpret_cast<std::complex<double>* >(B); + for (int i=0;i<N;i++) + B_stl[i] = B_cplx[i]; + } + + static inline void copy_vector(const gene_vector & source, gene_vector & cible, int N){ + for (int i=0;i<N;i++) { + cible[i][0]=source[i][0]; + cible[i][1]=source[i][1]; + } + } + + /* Begin FFTW operations */ + + static inline void fftw_init_plan(plan & p, const int & N, gene_vector & x, gene_vector & y, const int & sign, const int & flags){ + p = fftw_plan_dft_1d(N, x, y, sign, flags); + } + + static inline void fftw_init_plan_2d(plan & p, const int & N, gene_vector & x, gene_vector& y, const int & sign, const int & flags){ + p = fftw_plan_dft_2d(N, N, x, y, sign, flags); + } + + static inline void fftw_init_plan_3d(plan & p, const int & N, gene_vector & x, gene_vector& y, const int & sign, const int & flags){ + p = fftw_plan_dft_3d(N, N, N, x, y, sign, flags); + } + + static inline void fftw_run(plan & p){ + fftw_execute(p); + } +}; + +#endif // BTL_FFTW_INTERFACE_H diff --git a/btl/libs/FFTW/main.cpp b/btl/libs/FFTW/main.cpp new file mode 100644 index 0000000..8fa452b --- /dev/null +++ b/btl/libs/FFTW/main.cpp @@ -0,0 +1,107 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#include "utilities.h" +#include "bench.hh" +#include "fftw_interface.hh" +#include "fftw_actions.hh" + +#include <string> + +BTL_MAIN; + +int main(int argc, char **argv) +{ + bool + fftw_1d_forward_measure = false, + fftw_1d_forward_estimate = false, + fftw_1d_backward_measure = false, + fftw_1d_backward_estimate = false, + + fftw_2d_forward_measure = false, + fftw_2d_forward_estimate = false, + fftw_2d_backward_measure = false, + fftw_2d_backward_estimate = false, + + fftw_3d_forward_measure = false, + fftw_3d_forward_estimate = false, + fftw_3d_backward_measure = false, + fftw_3d_backward_estimate = false + ; + int N = 100; + + + for (int i = 1; i < argc; ++i) { + std::string arg = argv[i]; + + if (arg == "FFTW_1D_Forward_Measure" || arg == "all") fftw_1d_forward_measure = true; + else if (arg == "FFTW_1D_Forward_Estimate" || arg == "all") fftw_1d_forward_estimate = true; + else if (arg == "FFTW_1D_Backward_Measure" || arg == "all") fftw_1d_backward_measure = true; + else if (arg == "FFTW_1D_Backward_Estimate" || arg == "all") fftw_1d_backward_estimate = true; + + else if (arg == "FFTW_2D_Forward_Measure" || arg == "all") fftw_2d_forward_measure = true; + else if (arg == "FFTW_2D_Forward_Estimate" || arg == "all") fftw_2d_forward_estimate = true; + else if (arg == "FFTW_2D_Backward_Measure" || arg == "all") fftw_2d_backward_measure = true; + else if (arg == "FFTW_2D_Backward_Estimate" || arg == "all") fftw_2d_backward_estimate = true; + + else if (arg == "FFTW_3D_Forward_Measure" || arg == "all") fftw_3d_forward_measure = true; + else if (arg == "FFTW_3D_Forward_Estimate" || arg == "all") fftw_3d_forward_estimate = true; + else if (arg == "FFTW_3D_Backward_Measure" || arg == "all") fftw_3d_backward_measure = true; + else if (arg == "FFTW_3D_Backward_Estimate" || arg == "all") fftw_3d_backward_estimate = true; + + // Check switch -N + else if (arg[0] == '-' && arg[1] == 'N') { + if (arg[2] != '\0') + N = atoi(arg.c_str()+2); + else + N = atoi(argv[++i]); + } + } + + + if (fftw_1d_forward_measure) + bench<Action_FFTW_1D_Forward_Measure<fftw_interface> >(MIN_MV,MAX_MV, N); + if (fftw_1d_forward_estimate) + bench<Action_FFTW_1D_Forward_Estimate<fftw_interface> >(MIN_MV,MAX_MV, N); + if (fftw_1d_backward_measure) + bench<Action_FFTW_1D_Backward_Measure<fftw_interface> >(MIN_MV,MAX_MV, N); + if (fftw_1d_backward_estimate) + bench<Action_FFTW_1D_Backward_Estimate<fftw_interface> >(MIN_MV,MAX_MV, N); + + if (fftw_2d_forward_measure) + bench<Action_FFTW_2D_Forward_Measure<fftw_interface> >(MIN_MV,MAX_MV, N); + if (fftw_2d_forward_estimate) + bench<Action_FFTW_2D_Forward_Estimate<fftw_interface> >(MIN_MV,MAX_MV, N); + if (fftw_2d_backward_measure) + bench<Action_FFTW_2D_Backward_Measure<fftw_interface> >(MIN_MV,MAX_MV, N); + if (fftw_2d_backward_estimate) + bench<Action_FFTW_2D_Backward_Estimate<fftw_interface> >(MIN_MV,MAX_MV, N); + + if (fftw_3d_forward_measure) + bench<Action_FFTW_3D_Forward_Measure<fftw_interface> >(MIN_MV,250, N); + if (fftw_3d_forward_estimate) + bench<Action_FFTW_3D_Forward_Estimate<fftw_interface> >(MIN_MV,250, N); + if (fftw_3d_backward_measure) + bench<Action_FFTW_3D_Backward_Measure<fftw_interface> >(MIN_MV,250, N); + if (fftw_3d_backward_estimate) + bench<Action_FFTW_3D_Backward_Estimate<fftw_interface> >(MIN_MV,250, N); + + + return 0; +} + + diff --git a/btl/libs/LAPACK/lapack.hh b/btl/libs/LAPACK/lapack.hh new file mode 100644 index 0000000..a6d46f1 --- /dev/null +++ b/btl/libs/LAPACK/lapack.hh @@ -0,0 +1,33 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef LAPACK_HH +#define LAPACK_HH + +#define SCALAR float +#define SCALAR_PREFIX s +#include "lapack_.hh" +#undef SCALAR +#undef SCALAR_PREFIX + +#define SCALAR double +#define SCALAR_PREFIX d +#include "lapack_.hh" +#undef SCALAR +#undef SCALAR_PREFIX + +#endif /* LAPACK_HH */ diff --git a/btl/libs/LAPACK/lapack_.hh b/btl/libs/LAPACK/lapack_.hh new file mode 100644 index 0000000..e7c8c3f --- /dev/null +++ b/btl/libs/LAPACK/lapack_.hh @@ -0,0 +1,38 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef CAT +# define CAT2(A,B) A##B +# define CAT(A,B) CAT2(A,B) +#endif +#define LAPACKFUNC(NAME) CAT(CAT(SCALAR_PREFIX,NAME),_) + +#ifdef __cplusplus +extern "C" { +#endif + +void LAPACKFUNC(getrf)(const int*, const int*, SCALAR*, const int*, int*, int*); +void LAPACKFUNC(potrf)(const char*, const int*, SCALAR*, const int*, int*); +void LAPACKFUNC(geqrf)(const int*, const int*, SCALAR*, const int*, SCALAR*, SCALAR*, const int*, int*); +void LAPACKFUNC(gesvd)(const char*, const char*, const int*, const int*, SCALAR*, const int*, SCALAR*, SCALAR*, const int*, SCALAR*, const int*, SCALAR*, const int*, int*); +void LAPACKFUNC(syev)(const char*, const char*, const int*, SCALAR*, const int*, SCALAR*, SCALAR*, const int*, int*); +void LAPACKFUNC(stev)(const char*, const int*, SCALAR*, SCALAR*, SCALAR*, const int*, SCALAR*, int*); + +#ifdef __cplusplus +} +#endif + diff --git a/btl/libs/LAPACK/lapack_interface.hh b/btl/libs/LAPACK/lapack_interface.hh new file mode 100644 index 0000000..a0ec52b --- /dev/null +++ b/btl/libs/LAPACK/lapack_interface.hh @@ -0,0 +1,78 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef LAPACK_INTERFACE_HH +#define LAPACK_INTERFACE_HH + +#include <../BLAS/c_interface_base.h> +#include <complex> +#include "lapack.hh" + +extern "C" { +#include "../BLAS/blas.h" + +//void sgesv_(int*, int*, float *, int*, int*, float *, int*, int*); +//void dgesv_(int*, int*, double*, int*, int*, double*, int*, int*); + +void sgels_(char*, int*, int*, int*, float *, int*, float *, int*, float *, int*, int*); +void dgels_(char*, int*, int*, int*, double*, int*, double*, int*, double*, int*, int*); + +//void sgetrf_(int*, int*, float *, int*, int*, int*); +//void dgetrf_(int*, int*, double*, int*, int*, int*); + +//void spotrf_(char*, int*, float *, int*, int*); +//void dpotrf_(char*, int*, double*, int*, int*); + +//void ssyev_(char*, char*, int*, float *, int*, float *, float *, int*, int*); +//void dsyev_(char*, char*, int*, double*, int*, double*, double*, int*, int*); +} + + +#define MAKE_STRING2(S) #S +#define MAKE_STRING(S) MAKE_STRING2(S) + +#ifndef CAT +# define CAT2(A,B) A##B +# define CAT(A,B) CAT2(A,B) +#endif + +template <typename real> class lapack_interface; + + +static char notrans = 'N'; +static char trans = 'T'; +static char nonunit = 'N'; +static char lower = 'L'; +static char right = 'R'; +static char left = 'L'; +static int intone = 1; +static int zeroint = 0; + + +#define SCALAR float +#define SCALAR_PREFIX s +#include "lapack_interface_impl.hh" +#undef SCALAR +#undef SCALAR_PREFIX + +#define SCALAR double +#define SCALAR_PREFIX d +#include "lapack_interface_impl.hh" +#undef SCALAR +#undef SCALAR_PREFIX + +#endif /* LAPACK_INTERFACE_HH */ diff --git a/btl/libs/LAPACK/lapack_interface_impl.hh b/btl/libs/LAPACK/lapack_interface_impl.hh new file mode 100644 index 0000000..a95bc5b --- /dev/null +++ b/btl/libs/LAPACK/lapack_interface_impl.hh @@ -0,0 +1,139 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#define LAPACKFUNC(NAME) CAT(CAT(SCALAR_PREFIX,NAME),_) + +template<> class lapack_interface<SCALAR> : public c_interface_base<SCALAR> +{ +public: + + static inline std::string name() + { + return MAKE_STRING(LAPACKNAME); + } + + static inline void general_solve(gene_matrix& A, gene_vector& b, gene_vector& x, int N) + { + int *ipiv = new int[N]; + int info; + LAPACKFUNC(copy)(&N, b, &intone, x, &intone); + LAPACKFUNC(gesv)(&N, &intone, A, &N, ipiv, x, &N, &info); + delete[] ipiv; + } + + static inline void least_squares(gene_matrix& A, gene_vector& b, gene_vector& x, int N) + { + int *ipiv = new int[N]; + int info; + LAPACKFUNC(copy)(&N, b, &intone, x, &intone); + SCALAR work1; + int MONE = -1; + LAPACKFUNC(gels)(¬rans, &N, &N, &intone, A, &N, x, &N, &work1, &MONE, &info); + int lwork = (int)work1; + SCALAR *work2 = new SCALAR[lwork]; + LAPACKFUNC(gels)(¬rans, &N, &N, &intone, A, &N, x, &N, work2, &lwork, &info); + delete[] work2; + delete[] ipiv; + } + + static inline void lu_decomp(const gene_matrix& X, gene_matrix& C, int N) + { + int N2 = N*N; + int *ipiv = new int[N]; + int info; + LAPACKFUNC(copy)(&N2, X, &intone, C, &intone); + LAPACKFUNC(getrf)(&N, &N, C, &N, ipiv, &info); + delete[] ipiv; + } + + static inline void cholesky(const gene_matrix& X, gene_matrix& C, int N) + { + int N2 = N*N; + int info; + LAPACKFUNC(copy)(&N2, X, &intone, C, &intone); + LAPACKFUNC(potrf)(&lower, &N, C, &N, &info); + } + + static inline void qr_decomp(const gene_matrix& X, gene_matrix& QR, gene_vector& tau, const int& N) + { + int N2 = N*N; + LAPACKFUNC(copy)(&N2, X, &intone, QR, &intone); + + SCALAR *work = new SCALAR; + int lwork = -1, info; + LAPACKFUNC(geqrf)(&N, &N, QR, &N, tau, work, &lwork, &info); + lwork = *work; + delete work; + work = new SCALAR[lwork]; + LAPACKFUNC(geqrf)(&N, &N, QR, &N, tau, work, &lwork, &info); + delete[] work; + } + + static inline void svd_decomp(const gene_matrix& X, gene_matrix& U, gene_vector& S, gene_matrix& VT, const int& N) + { + int N2 = N*N; + stl_vector Xcopy(N2); + LAPACKFUNC(copy)(&N2, X, &intone, &Xcopy[0], &intone); + + stl_vector work(1); + int lwork = -1, info; + LAPACKFUNC(gesvd)("A", "A", &N, &N, &Xcopy[0], &N, S, U, &N, VT, &N, &work[0], &lwork, &info); + lwork = work[0]; + work.resize(lwork); + LAPACKFUNC(gesvd)("A", "A", &N, &N, &Xcopy[0], &N, S, U, &N, VT, &N, &work[0], &lwork, &info); + } + + static inline void syev(const gene_matrix& X, gene_matrix& V, gene_vector& W, const int& N) + { + int N2 = N*N; + LAPACKFUNC(copy)(&N2, X, &intone, V, &intone); + + stl_vector work(1); + int lwork = -1, info; + LAPACKFUNC(syev)("V", "U", &N, V, &N, W, &work[0], &lwork, &info); + lwork = work[0]; + work.resize(lwork); + LAPACKFUNC(syev)("V", "U", &N, V, &N, W, &work[0], &lwork, &info); + } + + /* Size of D, W: N; size of E: N-1, size of V: NxN */ + static inline void stev(const gene_vector& D, const gene_vector& E, gene_vector& W, gene_matrix& V, const int& N) + { + int N0 = N; + int N1 = N-1; + LAPACKFUNC(copy)(&N0, D, &intone, W, &intone); + stl_vector E_(E, E+N-1), work(max(1, 2*N-2)); + + int info; + LAPACKFUNC(stev)("V", &N, W, &E_[0], V, &N, &work[0], &info); + } + + static inline void symm_ev(const gene_matrix& X, gene_vector& W, int N) + { + char jobz = 'N'; + SCALAR *work = new SCALAR; + int lwork = -1, info; + LAPACKFUNC(syev)(&jobz, &lower, &N, X, &N, W, work, &lwork, &info); + lwork = *work; + delete work; + work = new SCALAR[lwork]; + LAPACKFUNC(syev)(&jobz, &lower, &N, X, &N, W, work, &lwork, &info); + delete[] work; + } + + +}; diff --git a/btl/libs/LAPACK/main.cpp b/btl/libs/LAPACK/main.cpp new file mode 100644 index 0000000..e70c161 --- /dev/null +++ b/btl/libs/LAPACK/main.cpp @@ -0,0 +1,95 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#include <btl.hh> +#include <bench.hh> +#include <action_general_solve.hh> +#include <action_least_squares.hh> +#include <action_lu_decomp.hh> +#include <action_cholesky.hh> +#include <action_qr_decomp.hh> +#include <action_svd_decomp.hh> +#include <action_syev.hh> +#include <action_stev.hh> +#include <action_symm_ev.hh> +#include <lapack_interface.hh> + +#include <string> +#include <cstdlib> + +BTL_MAIN; + +int main(int argc, char **argv) +{ + bool + general_solve=false, least_squares=false, lu_decomp=false, cholesky=false, qr_decomp=false, svd_decomp=false, + syev=false, stev=false, symm_ev=false + ; + int N = 100; + + + for (int i = 1; i < argc; ++i) { + std::string arg = argv[i]; + if (arg == "general_solve") general_solve = true; + else if (arg == "least_squares") least_squares = true; + else if (arg == "lu_decomp") lu_decomp = true; + else if (arg == "cholesky") cholesky = true; + else if (arg == "qr_decomp") qr_decomp = true; + else if (arg == "svd_decomp") svd_decomp = true; + else if (arg == "syev") syev = true; + else if (arg == "stev") stev = true; + else if (arg == "symm_ev") symm_ev = true; + + // Check switch -N + else if (arg[0] == '-' && arg[1] == 'N') { + if (arg[2] != '\0') + N = atoi(arg.c_str()+2); + else + N = atoi(argv[++i]); + } + } + + + if (general_solve) + bench<Action_general_solve<lapack_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,N); + + if (least_squares) + bench<Action_least_squares<lapack_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,N); + + if (lu_decomp) + bench<Action_lu_decomp<lapack_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,N); + + if (cholesky) + bench<Action_cholesky<lapack_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,N); + + if (qr_decomp) + bench<Action_qr_decomp<lapack_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,N); + + if (svd_decomp) + bench<Action_svd_decomp<lapack_interface<REAL_TYPE> > >(MIN_MM,750,N); + + if (syev) + bench<Action_syev<lapack_interface<REAL_TYPE> > >(MIN_MM,750,N); + + if (stev) + bench<Action_stev<lapack_interface<REAL_TYPE> > >(MIN_MM,1000,N); + + if (symm_ev) + bench<Action_symm_ev<lapack_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,N); + + return 0; +} diff --git a/btl/libs/PBLAS/main.cpp b/btl/libs/PBLAS/main.cpp new file mode 100644 index 0000000..427cf7e --- /dev/null +++ b/btl/libs/PBLAS/main.cpp @@ -0,0 +1,103 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#define DISTRIBUTED + +#include "mpi.h" +#include "utilities.h" +#include "bench.hh" + +#include <iostream> +//using namespace std; + +#include "pblas_interface.hh" +#include "blacsinit.hh" + +#include "action_parallel_axpy.hh" +#include "action_parallel_matrix_vector_product.hh" +#include "action_parallel_lu_decomp.hh" +#include "action_parallel_cholesky.hh" +#include "action_parallel_qr_decomp.hh" +#include "action_parallel_svd_decomp.hh" +#include "action_parallel_symm_ev.hh" + +#include <string> + +BTL_MAIN; + +int main(int argc, char **argv) +{ + bool iamroot = blacsinit(&argc, &argv); + + bool + axpy=false, matrix_vector=false, + lu_decomp=false, cholesky=false, qr_decomp=false, svd_decomp=false, + symm_ev=false + ; + + int N = 100; + + + for (int i = 1; i < argc; ++i) { + std::string arg = argv[i]; + if (arg == "axpy") axpy = true; + else if (arg == "matrix_vector") matrix_vector=true; + else if (arg == "lu_decomp") lu_decomp = true; + else if (arg == "cholesky") cholesky = true; + else if (arg == "qr_decomp") qr_decomp = true; + else if (arg == "svd_decomp") svd_decomp = true; + else if (arg == "symm_ev") symm_ev = true; + + // Check switch -N + else if (arg[0] == '-' && arg[1] == 'N') { + if (arg[2] != '\0') + N = atoi(arg.c_str()+2); + else + N = atoi(argv[++i]); + } + } + + + + if (axpy) + distr_bench<Action_parallel_axpy<pblas_interface<REAL_TYPE> > >(MIN_AXPY,MAX_AXPY, N, !iamroot); + + if (matrix_vector) + distr_bench<Action_parallel_matrix_vector_product<pblas_interface<REAL_TYPE> > >(MIN_MV,MAX_MV, N, !iamroot); + + if (lu_decomp) + distr_bench<Action_parallel_lu_decomp<pblas_interface<REAL_TYPE> > >(MIN_MM,MAX_MM, N, !iamroot); + + if (cholesky) + distr_bench<Action_parallel_cholesky<pblas_interface<REAL_TYPE> > >(MIN_MM, MAX_MM, N, !iamroot); + + if (qr_decomp) + distr_bench<Action_parallel_qr_decomp<pblas_interface<REAL_TYPE> > >(MIN_MM,MAX_MM, N, !iamroot); + + if (svd_decomp) + distr_bench<Action_parallel_svd_decomp<pblas_interface<REAL_TYPE> > >(MIN_MM,750, N, !iamroot); + + if (symm_ev) + distr_bench<Action_parallel_symm_ev<pblas_interface<REAL_TYPE> > >(MIN_MM,750, N, !iamroot); + + + int iZERO = 0; + blacs_exit_(&iZERO); + return 0; +} + + diff --git a/btl/libs/PBLAS/pblas.h b/btl/libs/PBLAS/pblas.h new file mode 100644 index 0000000..be76e8f --- /dev/null +++ b/btl/libs/PBLAS/pblas.h @@ -0,0 +1,106 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef SCALAPACK_H_ +#define SCALAPACK_H_ + +#ifdef __cplusplus +extern "C" { +#endif + + int numroc_(const int*, const int*, const int*, const int*, const int*); + void descinit_(int*, const int*, const int*, const int*, const int*, const int*, const int*, const int*, const int*, int*); + + + /* Level 1 */ + + // Single + void psaxpy_(const int*, const float*, + const float*, const int*, const int*, const int*, const int*, + const float*, const int*, const int*, const int*, const int* + ); + + // Double + void pdaxpy_(const int*, const double*, + const double*, const int*, const int*, const int*, const int*, + const double*, const int*, const int*, const int*, const int* + ); + + + + /* Level 2 */ + + // Single + void psgemv_(const char*, const int*, const int*, + const float*, const float*, const int*, const int*, const int*, + const float*, const int*, const int*, const int*, const int*, + const float*, float*, const int*, const int*, const int*, const int* + ); + + // Double + void pdgemv_(const char*, const int*, const int*, + const double*, const double*, const int*, const int*, const int*, + const double*, const int*, const int*, const int*, const int*, + const double*, double*, const int*, const int*, const int*, const int* + ); + + + /* Level 3 */ + + // Single + void pstrmm_(const char*, const char*, const char*, const char*, const int*, const int*, const float*, + const float*, const int*, const int*, const int*, + float*, const int*, const int*, const int*); + + // Double + void pdtrmm_(const char*, const char*, const char*, const char*, const int*, const int*, const double*, + const double*, const int*, const int*, const int*, + double*, const int*, const int*, const int*); + + + + /************* + * Scalapack * + *************/ + // lu_decomp + void psgetrf_(const int*, const int*, float*, const int*, const int*, const int*, int*, int*); + void pdgetrf_(const int*, const int*, double*, const int*, const int*, const int*, int*, int*); + + // cholesky + void pspotrf_(const char*, const int*, float*, const int*, const int*, const int*, int*); + void pdpotrf_(const char*, const int*, double*, const int*, const int*, const int*, int*); + + // qr_decomp + void psgeqpf_(const int*, const int*, float*, const int*, const int*, const int*, int*, float*, float*, const int*, int*); + void pdgeqpf_(const int*, const int*, double*, const int*, const int*, const int*, int*, double*, double*, const int*, int*); + + // svd_decomp + void psgesvd_(const char*, const char*, const int*, const int*, float*, const int*, const int*, const int*, float*, float*, const int*, const int*, const int*, float*, const int*, const int*, const int*, float*, const int*, int*); + void pdgesvd_(const char*, const char*, const int*, const int*, double*, const int*, const int*, const int*, double*, double*, const int*, const int*, const int*, double*, const int*, const int*, const int*, double*, const int*, int*); + + // symm_ev + void pssyevd_(const char*, const char*, const int*, float*, const int*, const int*, const int*, float*, float*, const int*, const int*, const int*, float*, const int*, int*, const int*, int*); + void pdsyevd_(const char*, const char*, const int*, double*, const int*, const int*, const int*, double*, double*, const int*, const int*, const int*, double*, const int*, int*, const int*, int*); + + +#ifdef __cplusplus +} +#endif + + + +#endif /* SCALAPACK_H_ */ diff --git a/btl/libs/PBLAS/pblas_interface.hh b/btl/libs/PBLAS/pblas_interface.hh new file mode 100644 index 0000000..6dfd201 --- /dev/null +++ b/btl/libs/PBLAS/pblas_interface.hh @@ -0,0 +1,57 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#include "blas.h" +#include "pblas.h" +#include "blacs_interface.hh" + +#define MAKE_STRING2(S) #S +#define MAKE_STRING(S) MAKE_STRING2(S) + +#ifndef CAT +#define CAT2(A,B) A##B +#define CAT(A,B) CAT2(A,B) +#endif + + +template<class real> class pblas_interface; + +/* +static char notrans = 'N'; +static char trans = 'T'; +static char nonunit = 'N'; +static char lower = 'L'; +static char right = 'R'; +static char left = 'L'; +static int intone = 1; +*/ + +#define SCALAR float +#define SCALAR_PREFIX s +#include "pblas_interface_impl.hh" +#undef SCALAR +#undef SCALAR_PREFIX + + +#define SCALAR double +#define SCALAR_PREFIX d +#include "pblas_interface_impl.hh" +#undef SCALAR +#undef SCALAR_PREFIX + + + diff --git a/btl/libs/PBLAS/pblas_interface_impl.hh b/btl/libs/PBLAS/pblas_interface_impl.hh new file mode 100644 index 0000000..a96b0fd --- /dev/null +++ b/btl/libs/PBLAS/pblas_interface_impl.hh @@ -0,0 +1,246 @@ +//===================================================== +// Copyright (C) 2011 Andrea Arteaga <andyspiros@gmail.com> +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// + +#define PBLAS_PREFIX p +#define PBLAS_FUNC(NAME) CAT(CAT(CAT(PBLAS_PREFIX, SCALAR_PREFIX),NAME),_) +#define BLAS_FUNC(NAME) CAT(CAT(SCALAR_PREFIX,NAME),_) + +template<> class pblas_interface<SCALAR> : public blacs_interface<SCALAR> +{ +public: + static inline std::string name() + { + return MAKE_STRING(PBLASNAME); + } + + static inline void parallel_axpy(const SCALAR& coef, + gene_vector& x, int *descX, + gene_vector& y, int *descY, + const int& size + ) + { + int iZERO = 0, iONE = 1; + PBLAS_FUNC(axpy)(&size, &coef, + x, &iONE, &iONE, descX, &iONE, + y, &iONE, &iONE, descY, &iONE + ); + } + + static inline void parallel_matrix_vector_product( + int GlobalRows, int GlobalCols, + gene_matrix& A, int *descA, + gene_vector& x, int *descX, + gene_vector& y, int *descY + ) + { + real_type alpha = 1., beta = 0.; + int iONE = 1; + int myid, procnum; + const char notrans = 'N'; + blacs_pinfo_(&myid, &procnum); + + PBLAS_FUNC(gemv)(¬rans, &GlobalRows, &GlobalCols, + &alpha, A, &iONE, &iONE, descA, + x, &iONE, &iONE, descX, &iONE, + &beta, y, &iONE, &iONE, descY, &iONE + ); + + } + + + static inline void parallel_lu_decomp(gene_matrix& X, std::vector<int>& ipiv, const int* desc) + { + const int GlobalRows = desc[2], GlobalCols = desc[3]; + const int iONE = 1; + int info; + ipiv.resize(desc[8] + desc[4]); + PBLAS_FUNC(getrf)(&GlobalRows, &GlobalCols, X, &iONE, &iONE, desc, + &ipiv[0], &info); + if (info != 0 && myid() == 0) + cout << " { LU error : " << info << " } "; + } + + static inline void parallel_cholesky(gene_matrix& X, const int* desc) + { + const int N = desc[2], iONE = 1; + const char UP = 'U'; + int info; + PBLAS_FUNC(potrf)(&UP, &N, X, &iONE, &iONE, desc, &info); + if (info != 0 && myid() == 0) + cout << " { cholesky error : " << info << " } "; + } + + static inline void parallel_qr_decomp(gene_matrix& X, const int* desc) + { + const int GlobalRows = desc[2], GlobalCols = desc[3], + BlockRows = desc[4], BlockCols = desc[5], + ctxt = desc[1]; + + int myrow, mycol, nprow, npcol, lwork; + SCALAR lworkd; + blacs_gridinfo_(&ctxt, &nprow, &npcol, &myrow, &mycol); + + const int iONE = 1, iZERO = 0, imONE = -1, + ipivdim = numroc_(&GlobalCols, &BlockCols, &mycol, &iZERO, &npcol); + int info; + std::vector<int> ipiv(ipivdim); + std::vector<SCALAR> tau(ipivdim); + + // Retrieve LWORK + PBLAS_FUNC(geqpf)(&GlobalRows, &GlobalCols, X, &iONE, &iONE, desc, &ipiv[0], &tau[0], &lworkd, &imONE, &info); + lwork = static_cast<int>(lworkd); + if (info != 0 && myid() == 0) + cout << " { qr_decomp lwork error } "; + + std::vector<SCALAR> work(lwork); + PBLAS_FUNC(geqpf)(&GlobalRows, &GlobalCols, X, &iONE, &iONE, desc, &ipiv[0], &tau[0], &work[0], &lwork, &info); + if (info != 0 && myid() == 0) + cout << " { qr_decomp computation error } "; + } + + static inline void parallel_symm_ev(gene_matrix& A, const int* descA, gene_vector& w, gene_matrix& Z, const int* descZ) + { + const char jobz = 'V', uplo = 'u'; + const int N = descA[2], iONE = 1, iZERO = 0, imONE = -1; + std::vector<SCALAR> work; + std::vector<int> iwork; + int lwork, liwork, info; + SCALAR lworkd; + + // Retrieve l(i)work + PBLAS_FUNC(syevd)(&jobz, &uplo, &N, A, &iONE, &iONE, descA, w, + Z, &iONE, &iONE, descZ, &lworkd, &imONE, &liwork, &imONE, &info); + lwork = static_cast<int>(lworkd); + work.resize(lwork); iwork.resize(liwork); + if (info != 0 && myid() == 0) + cout << " { symm_ev l(i)work error } "; + + PBLAS_FUNC(syevd)(&jobz, &uplo, &N, A, &iONE, &iONE, descA, w, + Z, &iONE, &iONE, descZ, &work[0], &lwork, &iwork[0], &liwork, &info); + if (info != 0 && myid() == 0) + cout << " { symm_ev computation error } "; + } + + static inline void parallel_svd_decomp(gene_matrix& A, int* descA, gene_matrix& U, int *descU, gene_matrix& V, int *descV, gene_vector& s) + { + const char job = 'V'; + const int size = descA[2], iONE = 1, iZERO = 0, imONE = -1; + std::vector<SCALAR> work; + int info, lwork; + SCALAR lworkd; + + // Retrieve lwork + PBLAS_FUNC(gesvd)(&job, &job, &size, &size, A, &iONE, &iONE, descA, s, + U, &iONE, &iONE, descU, V, &iONE, &iONE, descV, &lworkd, &imONE, &info); + if (info != 0 && myid() == 0) + cout << " { svd_decomp lwork error } "; + lwork = static_cast<int>(lworkd); + work.resize(lwork); + + PBLAS_FUNC(gesvd)(&job, &job, &size, &size, A, &iONE, &iONE, descA, s, + U, &iONE, &iONE, descU, V, &iONE, &iONE, descV, &work[0], &lwork, &info); + if (info != 0 && myid() == 0) + cout << " { svd_decomp computation error } "; + } + + static inline real_type + test_LU(stl_matrix& Global_A, gene_matrix& Local_LU, int *desc) + { + bool iamroot = myid() == 0; + int _size = desc[2]; + + // Create and scatter Identity + int Testdesc[9]; + stl_matrix Global_Test_stl, Local_Test_stl; + if (iamroot) + { + stl_matrix Identity(_size * _size); + for (int r = 0; r < _size; ++r) + Identity[r + _size * r] = 1; + scatter_matrix(Identity, Local_Test_stl, Testdesc, _size, _size, + desc[4], desc[5]); + } + else + scatter_matrix(stl_matrix(), Local_Test_stl, Testdesc); + + // Compute L * U + real_type alpha = 1., malpha = -1; + int iONE = 1; + PBLAS_FUNC(trmm)("L", "L", "N", "N", desc + 2, desc + 2, &alpha, Local_LU, + &iONE, &iONE, desc, &Local_Test_stl[0], &iONE, &iONE, Testdesc); + PBLAS_FUNC(trmm)("R", "U", "N", "N", desc + 2, desc + 2, &alpha, Local_LU, + &iONE, &iONE, desc, &Local_Test_stl[0], &iONE, &iONE, Testdesc); + + // Gather result + gather_matrix(Global_Test_stl, Local_Test_stl, desc); + if (iamroot) + { + int size2 = _size*_size; + BLAS_FUNC(axpy)(&size2, &malpha, &Global_A[0], &iONE, + &Global_Test_stl[0], &iONE); + double error = BLAS_FUNC(nrm2)(&size2, &Global_Test_stl[0], &iONE); + error /= BLAS_FUNC(nrm2)(&size2, &Global_A[0], &iONE); + return error; + } + else + return 0.; + } + + static inline real_type + test_cholesky(stl_matrix& Global_A, gene_matrix& Local_U, int *desc) + { + bool iamroot = myid() == 0; + int _size = desc[2]; + + // Create and scatter Identity + int Testdesc[9]; + stl_matrix Global_Test_stl, Local_Test_stl; + if (iamroot) + { + stl_matrix Identity(_size * _size); + for (int r = 0; r < _size; ++r) + Identity[r + _size * r] = 1; + scatter_matrix(Identity, Local_Test_stl, Testdesc, _size, _size, + desc[4], desc[5]); + } + else + scatter_matrix(stl_matrix(), Local_Test_stl, Testdesc); + + // Compute U' * U + real_type alpha = 1., malpha = -1; + int iONE = 1; + PBLAS_FUNC(trmm)("L", "U", "T", "N", desc + 2, desc + 2, &alpha, Local_U, + &iONE, &iONE, desc, &Local_Test_stl[0], &iONE, &iONE, Testdesc); + PBLAS_FUNC(trmm)("R", "U", "N", "N", desc + 2, desc + 2, &alpha, Local_U, + &iONE, &iONE, desc, &Local_Test_stl[0], &iONE, &iONE, Testdesc); + + // Gather result + gather_matrix(Global_Test_stl, Local_Test_stl, desc); + if (iamroot) + { + int size2 = _size*_size; + BLAS_FUNC(axpy)(&size2, &malpha, &Global_A[0], &iONE, + &Global_Test_stl[0], &iONE); + double error = BLAS_FUNC(nrm2)(&size2, &Global_Test_stl[0], &iONE); + error /= BLAS_FUNC(nrm2)(&size2, &Global_A[0], &iONE); + return error; + } + else + return 0.; + } +}; diff --git a/btl/libs/STL/CMakeLists.txt b/btl/libs/STL/CMakeLists.txt new file mode 100644 index 0000000..4cfc2dc --- /dev/null +++ b/btl/libs/STL/CMakeLists.txt @@ -0,0 +1,2 @@ + +btl_add_bench(btl_STL main.cpp OFF) diff --git a/btl/libs/STL/STL_interface.hh b/btl/libs/STL/STL_interface.hh new file mode 100644 index 0000000..060cb69 --- /dev/null +++ b/btl/libs/STL/STL_interface.hh @@ -0,0 +1,255 @@ +//===================================================== +// File : STL_interface.hh +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, lun sep 30 14:23:24 CEST 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#ifndef STL_INTERFACE_HH +#define STL_INTERFACE_HH +#include <string> +#include <vector> +#include "utilities.h" + +using namespace std; + +template<class real> +class STL_interface{ + +public : + + typedef real real_type ; + + typedef std::vector<real> stl_vector; + typedef std::vector<stl_vector > stl_matrix; + + typedef stl_matrix gene_matrix; + + typedef stl_vector gene_vector; + + static inline std::string name( void ) + { + return "STL"; + } + + static void free_matrix(gene_matrix & A, int N){} + + static void free_vector(gene_vector & B){} + + static inline void matrix_from_stl(gene_matrix & A, stl_matrix & A_stl){ + A = A_stl; + } + + static inline void vector_from_stl(gene_vector & B, stl_vector & B_stl){ + B = B_stl; + } + + static inline void vector_to_stl(gene_vector & B, stl_vector & B_stl){ + B_stl = B ; + } + + + static inline void matrix_to_stl(gene_matrix & A, stl_matrix & A_stl){ + A_stl = A ; + } + + static inline void copy_vector(const gene_vector & source, gene_vector & cible, int N){ + for (int i=0;i<N;i++){ + cible[i]=source[i]; + } + } + + + static inline void copy_matrix(const gene_matrix & source, gene_matrix & cible, int N){ + for (int i=0;i<N;i++) + for (int j=0;j<N;j++) + cible[i][j]=source[i][j]; + } + +// static inline void ata_product(const gene_matrix & A, gene_matrix & X, int N) +// { +// real somme; +// for (int j=0;j<N;j++){ +// for (int i=0;i<N;i++){ +// somme=0.0; +// for (int k=0;k<N;k++) +// somme += A[i][k]*A[j][k]; +// X[j][i]=somme; +// } +// } +// } + + static inline void aat_product(const gene_matrix & A, gene_matrix & X, int N) + { + real somme; + for (int j=0;j<N;j++){ + for (int i=0;i<N;i++){ + somme=0.0; + if(i>=j) + { + for (int k=0;k<N;k++){ + somme+=A[k][i]*A[k][j]; + } + X[j][i]=somme; + } + } + } + } + + + static inline void matrix_matrix_product(const gene_matrix & A, const gene_matrix & B, gene_matrix & X, int N) + { + real somme; + for (int j=0;j<N;j++){ + for (int i=0;i<N;i++){ + somme=0.0; + for (int k=0;k<N;k++) + somme+=A[k][i]*B[j][k]; + X[j][i]=somme; + } + } + } + + static inline void matrix_vector_product(gene_matrix & A, gene_vector & B, gene_vector & X, int N) + { + real somme; + for (int i=0;i<N;i++){ + somme=0.0; + for (int j=0;j<N;j++) + somme+=A[j][i]*B[j]; + X[i]=somme; + } + } + + static inline void matrix_vector_product(gene_vector& A, gene_vector & B, gene_vector & X, int N) + { + real somme; + for (int i=0;i<N;i++){ + somme=0.0; + for (int j=0;j<N;j++) + somme+=A[j*N+i]*B[j]; + X[i]=somme; + } + } + + static inline void symv(gene_matrix & A, gene_vector & B, gene_vector & X, int N) + { + for (int j=0; j<N; ++j) + X[j] = 0; + for (int j=0; j<N; ++j) + { + real t1 = B[j]; + real t2 = 0; + X[j] += t1 * A[j][j]; + for (int i=j+1; i<N; ++i) { + X[i] += t1 * A[j][i]; + t2 += A[j][i] * B[i]; + } + X[j] += t2; + } + } + + static inline void syr2(gene_matrix & A, gene_vector & B, gene_vector & X, int N) + { + for (int j=0; j<N; ++j) + { + for (int i=j; i<N; ++i) + A[j][i] += B[i]*X[j] + B[j]*X[i]; + } + } + + static inline void ger(gene_matrix & A, gene_vector & X, gene_vector & Y, int N) + { + for (int j=0; j<N; ++j) + { + for (int i=j; i<N; ++i) + A[j][i] += X[i]*Y[j]; + } + } + + static inline void atv_product(gene_matrix & A, gene_vector & B, gene_vector & X, int N) + { + real somme; + for (int i=0;i<N;i++){ + somme = 0.0; + for (int j=0;j<N;j++) + somme += A[i][j]*B[j]; + X[i] = somme; + } + } + + static inline void axpy(real coef, const gene_vector & X, gene_vector & Y, int N){ + for (int i=0;i<N;i++) + Y[i]+=coef*X[i]; + } + + static inline void axpby(real a, const gene_vector & X, real b, gene_vector & Y, int N){ + for (int i=0;i<N;i++) + Y[i] = a*X[i] + b*Y[i]; + } + + static inline void trisolve_lower(const gene_matrix & L, const gene_vector & B, gene_vector & X, int N){ + copy_vector(B,X,N); + for(int i=0; i<N; ++i) + { + X[i] /= L[i][i]; + real tmp = X[i]; + for (int j=i+1; j<N; ++j) + X[j] -= tmp * L[i][j]; + } + } + + static inline real norm_diff(const stl_vector & A, const stl_vector & B) + { + int N=A.size(); + real somme=0.0; + real somme2=0.0; + + for (int i=0;i<N;i++){ + real diff=A[i]-B[i]; + somme+=diff*diff; + somme2+=A[i]*A[i]; + } + return somme/somme2; + } + + static inline real norm_diff(const stl_matrix & A, const stl_matrix & B) + { + int N=A[0].size(); + real somme=0.0; + real somme2=0.0; + + for (int i=0;i<N;i++){ + for (int j=0;j<N;j++){ + real diff=A[i][j] - B[i][j]; + somme += diff*diff; + somme2 += A[i][j]*A[i][j]; + } + } + + return somme/somme2; + } + + static inline void display_vector(const stl_vector & A) + { + int N=A.size(); + for (int i=0;i<N;i++){ + INFOS("A["<<i<<"]="<<A[i]<<endl); + } + } + +}; + +#endif diff --git a/btl/libs/STL/main.cpp b/btl/libs/STL/main.cpp new file mode 100644 index 0000000..4e73328 --- /dev/null +++ b/btl/libs/STL/main.cpp @@ -0,0 +1,42 @@ +//===================================================== +// File : main.cpp +// Author : L. Plagne <laurent.plagne@edf.fr)> +// Copyright (C) EDF R&D, lun sep 30 14:23:23 CEST 2002 +//===================================================== +// +// This program is free software; you can redistribute it and/or +// modify it under the terms of the GNU General Public License +// as published by the Free Software Foundation; either version 2 +// of the License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +// +#include "utilities.h" +#include "STL_interface.hh" +#include "bench.hh" +#include "basic_actions.hh" + +BTL_MAIN; + +int main() +{ + bench<Action_axpy<STL_interface<REAL_TYPE> > >(MIN_AXPY,MAX_AXPY,NB_POINT); + bench<Action_axpby<STL_interface<REAL_TYPE> > >(MIN_AXPY,MAX_AXPY,NB_POINT); + bench<Action_matrix_vector_product<STL_interface<REAL_TYPE> > >(MIN_MV,MAX_MV,NB_POINT); + bench<Action_atv_product<STL_interface<REAL_TYPE> > >(MIN_MV,MAX_MV,NB_POINT); + bench<Action_symv<STL_interface<REAL_TYPE> > >(MIN_MV,MAX_MV,NB_POINT); + bench<Action_syr2<STL_interface<REAL_TYPE> > >(MIN_MV,MAX_MV,NB_POINT); + bench<Action_matrix_matrix_product<STL_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT); + bench<Action_ata_product<STL_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT); + bench<Action_aat_product<STL_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT); + + return 0; +} + + diff --git a/numbench/benchconfig.py b/numbench/benchconfig.py index 244ac63..c0d8e8e 100644 --- a/numbench/benchconfig.py +++ b/numbench/benchconfig.py @@ -32,7 +32,7 @@ if not locals().has_key('initialized'): if os.environ.has_key('BTLDIR'): btldir = os.environ['BTLDIR'] else: - btldir = '/usr/include/btl' + btldir = '/usr/include/numbench/btl' # Library directory (lib vs. lib32 vs. lib64) libdir = sp.Popen \ @@ -19,6 +19,7 @@ # import os +from os.path import isdir, join as pjoin from distutils.core import setup def recursiveGetPackage(pkg, directory): @@ -34,12 +35,29 @@ setupdir = os.path.dirname(os.path.abspath(__file__)) numdir = os.path.join(setupdir, 'numbench') +def recursiveGetBTL(frompath, topath): + + ls = [i for i in os.listdir(frompath)] + dirs = [i for i in ls if isdir(pjoin(frompath, i))] + files = [pjoin(frompath, i) for i in ls if not i in dirs] + + ret = [(topath, files)] + + for d in dirs: + ret += recursiveGetBTL(pjoin(frompath, d), pjoin(topath, d)) + + return ret + + + setup(name='Numbench', - version='1.0', + version='0.2', description='Numerical benchmarks for Gentoo', author='Andrea Arteaga', author_email='andyspiros@gmail.com', - url='http://soc.dev.gentoo.org/~spiros', + url='http://github.com/andyspiros/numbench', + license='GPL-2', packages=recursiveGetPackage('', numdir), + data_files=recursiveGetBTL('btl', 'include/numbench/btl') ) |