Disabled external gits
This commit is contained in:
107
cs440-acg/ext/eigen/bench/btl/CMakeLists.txt
Normal file
107
cs440-acg/ext/eigen/bench/btl/CMakeLists.txt
Normal file
@@ -0,0 +1,107 @@
|
||||
PROJECT(BTL)
|
||||
|
||||
CMAKE_MINIMUM_REQUIRED(VERSION 2.6.2)
|
||||
|
||||
set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake ${Eigen_SOURCE_DIR}/cmake)
|
||||
include(MacroOptionalAddSubdirectory)
|
||||
|
||||
OPTION(BTL_NOVEC "Disable SSE/Altivec optimizations when possible" OFF)
|
||||
|
||||
SET(CMAKE_INCLUDE_CURRENT_DIR ON)
|
||||
|
||||
string(REGEX MATCH icpc IS_ICPC ${CMAKE_CXX_COMPILER})
|
||||
IF(CMAKE_COMPILER_IS_GNUCXX OR IS_ICPC)
|
||||
SET(CMAKE_CXX_FLAGS "-g0 -O3 -DNDEBUG ${CMAKE_CXX_FLAGS}")
|
||||
SET(CMAKE_Fortran_FLAGS "-g0 -O3 -DNDEBUG ${CMAKE_Fortran_FLAGS}")
|
||||
IF(BTL_NOVEC)
|
||||
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DEIGEN_DONT_VECTORIZE")
|
||||
ENDIF(BTL_NOVEC)
|
||||
ENDIF(CMAKE_COMPILER_IS_GNUCXX OR IS_ICPC)
|
||||
|
||||
IF(MSVC)
|
||||
SET(CMAKE_CXX_FLAGS " /O2 /Ot /GL /fp:fast -DNDEBUG")
|
||||
# SET(CMAKE_Fortran_FLAGS "-g0 -O3 -DNDEBUG")
|
||||
IF(BTL_NOVEC)
|
||||
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DEIGEN_DONT_VECTORIZE")
|
||||
ENDIF(BTL_NOVEC)
|
||||
ENDIF(MSVC)
|
||||
|
||||
if(IS_ICPC)
|
||||
set(CMAKE_CXX_FLAGS "-fast ${CMAKE_CXX_FLAGS}")
|
||||
set(CMAKE_Fortran_FLAGS "-fast ${CMAKE_Fortran_FLAGS}")
|
||||
endif(IS_ICPC)
|
||||
|
||||
include_directories(
|
||||
${PROJECT_SOURCE_DIR}/actions
|
||||
${PROJECT_SOURCE_DIR}/generic_bench
|
||||
${PROJECT_SOURCE_DIR}/generic_bench/utils
|
||||
${PROJECT_SOURCE_DIR}/libs/STL)
|
||||
|
||||
# find_package(MKL)
|
||||
# if (MKL_FOUND)
|
||||
# add_definitions(-DHAVE_MKL)
|
||||
# set(DEFAULT_LIBRARIES ${MKL_LIBRARIES})
|
||||
# endif (MKL_FOUND)
|
||||
|
||||
find_library(EIGEN_BTL_RT_LIBRARY rt)
|
||||
# if we cannot find it easily, then we don't need it!
|
||||
if(NOT EIGEN_BTL_RT_LIBRARY)
|
||||
set(EIGEN_BTL_RT_LIBRARY "")
|
||||
endif()
|
||||
|
||||
MACRO(BTL_ADD_BENCH targetname)
|
||||
|
||||
foreach(_current_var ${ARGN})
|
||||
set(_last_var ${_current_var})
|
||||
endforeach(_current_var)
|
||||
|
||||
set(_sources ${ARGN})
|
||||
list(LENGTH _sources _argn_length)
|
||||
|
||||
list(REMOVE_ITEM _sources ON OFF TRUE FALSE)
|
||||
|
||||
list(LENGTH _sources _src_length)
|
||||
|
||||
if (${_argn_length} EQUAL ${_src_length})
|
||||
set(_last_var ON)
|
||||
endif (${_argn_length} EQUAL ${_src_length})
|
||||
|
||||
OPTION(BUILD_${targetname} "Build benchmark ${targetname}" ${_last_var})
|
||||
|
||||
IF(BUILD_${targetname})
|
||||
ADD_EXECUTABLE(${targetname} ${_sources})
|
||||
ADD_TEST(${targetname} "${targetname}")
|
||||
target_link_libraries(${targetname} ${DEFAULT_LIBRARIES} ${EIGEN_BTL_RT_LIBRARY})
|
||||
ENDIF(BUILD_${targetname})
|
||||
|
||||
ENDMACRO(BTL_ADD_BENCH)
|
||||
|
||||
macro(btl_add_target_property target prop value)
|
||||
|
||||
if(BUILD_${target})
|
||||
get_target_property(previous ${target} ${prop})
|
||||
if(NOT previous)
|
||||
set(previous "")
|
||||
endif()
|
||||
set_target_properties(${target} PROPERTIES ${prop} "${previous} ${value}")
|
||||
endif()
|
||||
|
||||
endmacro(btl_add_target_property)
|
||||
|
||||
ENABLE_TESTING()
|
||||
|
||||
add_subdirectory(libs/eigen3)
|
||||
add_subdirectory(libs/eigen2)
|
||||
add_subdirectory(libs/tensors)
|
||||
add_subdirectory(libs/BLAS)
|
||||
add_subdirectory(libs/ublas)
|
||||
add_subdirectory(libs/gmm)
|
||||
add_subdirectory(libs/mtl4)
|
||||
add_subdirectory(libs/blitz)
|
||||
add_subdirectory(libs/tvmet)
|
||||
add_subdirectory(libs/STL)
|
||||
add_subdirectory(libs/blaze)
|
||||
|
||||
add_subdirectory(data)
|
||||
|
||||
|
||||
340
cs440-acg/ext/eigen/bench/btl/COPYING
Normal file
340
cs440-acg/ext/eigen/bench/btl/COPYING
Normal file
@@ -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.
|
||||
154
cs440-acg/ext/eigen/bench/btl/README
Normal file
154
cs440-acg/ext/eigen/bench/btl/README
Normal file
@@ -0,0 +1,154 @@
|
||||
Bench Template Library
|
||||
|
||||
****************************************
|
||||
Introduction :
|
||||
|
||||
The aim of this project is to compare the performance
|
||||
of available numerical libraries. The code is designed
|
||||
as generic and modular as possible. Thus, adding new
|
||||
numerical libraries or new numerical tests should
|
||||
require minimal effort.
|
||||
|
||||
|
||||
*****************************************
|
||||
|
||||
Installation :
|
||||
|
||||
BTL uses cmake / ctest:
|
||||
|
||||
1 - create a build directory:
|
||||
|
||||
$ mkdir build
|
||||
$ cd build
|
||||
|
||||
2 - configure:
|
||||
|
||||
$ ccmake ..
|
||||
|
||||
3 - run the bench using ctest:
|
||||
|
||||
$ ctest -V
|
||||
|
||||
You can run the benchmarks only on libraries matching a given regular expression:
|
||||
ctest -V -R <regexp>
|
||||
For instance:
|
||||
ctest -V -R eigen2
|
||||
|
||||
You can also select a given set of actions defining the environment variable BTL_CONFIG this way:
|
||||
BTL_CONFIG="-a action1{:action2}*" ctest -V
|
||||
An exemple:
|
||||
BTL_CONFIG="-a axpy:vector_matrix:trisolve:ata" ctest -V -R eigen2
|
||||
|
||||
Finally, if bench results already exist (the bench*.dat files) then they merges by keeping the best for each matrix size. If you want to overwrite the previous ones you can simply add the "--overwrite" option:
|
||||
BTL_CONFIG="-a axpy:vector_matrix:trisolve:ata --overwrite" ctest -V -R eigen2
|
||||
|
||||
4 : Analyze the result. different data files (.dat) are produced in each libs directories.
|
||||
If gnuplot is available, choose a directory name in the data directory to store the results and type:
|
||||
$ cd data
|
||||
$ mkdir my_directory
|
||||
$ cp ../libs/*/*.dat my_directory
|
||||
Build the data utilities in this (data) directory
|
||||
make
|
||||
Then you can look the raw data,
|
||||
go_mean my_directory
|
||||
or smooth the data first :
|
||||
smooth_all.sh my_directory
|
||||
go_mean my_directory_smooth
|
||||
|
||||
|
||||
*************************************************
|
||||
|
||||
Files and directories :
|
||||
|
||||
generic_bench : all the bench sources common to all libraries
|
||||
|
||||
actions : sources for different action wrappers (axpy, matrix-matrix product) to be tested.
|
||||
|
||||
libs/* : bench sources specific to each tested libraries.
|
||||
|
||||
machine_dep : directory used to store machine specific Makefile.in
|
||||
|
||||
data : directory used to store gnuplot scripts and data analysis utilities
|
||||
|
||||
**************************************************
|
||||
|
||||
Principles : the code modularity is achieved by defining two concepts :
|
||||
|
||||
****** Action concept : This is a class defining which kind
|
||||
of test must be performed (e.g. a matrix_vector_product).
|
||||
An Action should define the following methods :
|
||||
|
||||
*** Ctor using the size of the problem (matrix or vector size) as an argument
|
||||
Action action(size);
|
||||
*** initialize : this method initialize the calculation (e.g. initialize the matrices and vectors arguments)
|
||||
action.initialize();
|
||||
*** calculate : this method actually launch the calculation to be benchmarked
|
||||
action.calculate;
|
||||
*** nb_op_base() : this method returns the complexity of the calculate method (allowing the mflops evaluation)
|
||||
*** name() : this method returns the name of the action (std::string)
|
||||
|
||||
****** Interface concept : This is a class or namespace defining how to use a given library and
|
||||
its specific containers (matrix and vector). Up to now an interface should following types
|
||||
|
||||
*** real_type : kind of float to be used (float or double)
|
||||
*** stl_vector : must correspond to std::vector<real_type>
|
||||
*** stl_matrix : must correspond to std::vector<stl_vector>
|
||||
*** gene_vector : the vector type for this interface --> e.g. (real_type *) for the C_interface
|
||||
*** gene_matrix : the matrix type for this interface --> e.g. (gene_vector *) for the C_interface
|
||||
|
||||
+ the following common methods
|
||||
|
||||
*** free_matrix(gene_matrix & A, int N) dealocation of a N sized gene_matrix A
|
||||
*** free_vector(gene_vector & B) dealocation of a N sized gene_vector B
|
||||
*** matrix_from_stl(gene_matrix & A, stl_matrix & A_stl) copy the content of an stl_matrix A_stl into a gene_matrix A.
|
||||
The allocation of A is done in this function.
|
||||
*** vector_to_stl(gene_vector & B, stl_vector & B_stl) copy the content of an stl_vector B_stl into a gene_vector B.
|
||||
The allocation of B is done in this function.
|
||||
*** matrix_to_stl(gene_matrix & A, stl_matrix & A_stl) copy the content of an gene_matrix A into an stl_matrix A_stl.
|
||||
The size of A_STL must corresponds to the size of A.
|
||||
*** vector_to_stl(gene_vector & A, stl_vector & A_stl) copy the content of an gene_vector A into an stl_vector A_stl.
|
||||
The size of B_STL must corresponds to the size of B.
|
||||
*** copy_matrix(gene_matrix & source, gene_matrix & cible, int N) : copy the content of source in cible. Both source
|
||||
and cible must be sized NxN.
|
||||
*** copy_vector(gene_vector & source, gene_vector & cible, int N) : copy the content of source in cible. Both source
|
||||
and cible must be sized N.
|
||||
|
||||
and the following method corresponding to the action one wants to be benchmarked :
|
||||
|
||||
*** matrix_vector_product(const gene_matrix & A, const gene_vector & B, gene_vector & X, int N)
|
||||
*** matrix_matrix_product(const gene_matrix & A, const gene_matrix & B, gene_matrix & X, int N)
|
||||
*** ata_product(const gene_matrix & A, gene_matrix & X, int N)
|
||||
*** aat_product(const gene_matrix & A, gene_matrix & X, int N)
|
||||
*** axpy(real coef, const gene_vector & X, gene_vector & Y, int N)
|
||||
|
||||
The bench algorithm (generic_bench/bench.hh) is templated with an action itself templated with
|
||||
an interface. A typical main.cpp source stored in a given library directory libs/A_LIB
|
||||
looks like :
|
||||
|
||||
bench< AN_ACTION < AN_INTERFACE > >( 10 , 1000 , 50 ) ;
|
||||
|
||||
this function will produce XY data file containing measured mflops as a function of the size for 50
|
||||
sizes between 10 and 10000.
|
||||
|
||||
This algorithm can be adapted by providing a given Perf_Analyzer object which determines how the time
|
||||
measurements must be done. For example, the X86_Perf_Analyzer use the asm rdtsc function and provides
|
||||
a very fast and accurate (but less portable) timing method. The default is the Portable_Perf_Analyzer
|
||||
so
|
||||
|
||||
bench< AN_ACTION < AN_INTERFACE > >( 10 , 1000 , 50 ) ;
|
||||
|
||||
is equivalent to
|
||||
|
||||
bench< Portable_Perf_Analyzer,AN_ACTION < AN_INTERFACE > >( 10 , 1000 , 50 ) ;
|
||||
|
||||
If your system supports it we suggest to use a mixed implementation (X86_perf_Analyzer+Portable_Perf_Analyzer).
|
||||
replace
|
||||
bench<Portable_Perf_Analyzer,Action>(size_min,size_max,nb_point);
|
||||
with
|
||||
bench<Mixed_Perf_Analyzer,Action>(size_min,size_max,nb_point);
|
||||
in generic/bench.hh
|
||||
|
||||
.
|
||||
|
||||
|
||||
|
||||
145
cs440-acg/ext/eigen/bench/btl/actions/action_aat_product.hh
Normal file
145
cs440-acg/ext/eigen/bench/btl/actions/action_aat_product.hh
Normal file
@@ -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
|
||||
|
||||
|
||||
|
||||
145
cs440-acg/ext/eigen/bench/btl/actions/action_ata_product.hh
Normal file
145
cs440-acg/ext/eigen/bench/btl/actions/action_ata_product.hh
Normal file
@@ -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
|
||||
|
||||
|
||||
|
||||
134
cs440-acg/ext/eigen/bench/btl/actions/action_atv_product.hh
Normal file
134
cs440-acg/ext/eigen/bench/btl/actions/action_atv_product.hh
Normal file
@@ -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
|
||||
|
||||
|
||||
|
||||
127
cs440-acg/ext/eigen/bench/btl/actions/action_axpby.hh
Normal file
127
cs440-acg/ext/eigen/bench/btl/actions/action_axpby.hh
Normal file
@@ -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 ):_alpha(0.5),_beta(0.95),_size(size)
|
||||
{
|
||||
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
|
||||
139
cs440-acg/ext/eigen/bench/btl/actions/action_axpy.hh
Normal file
139
cs440-acg/ext/eigen/bench/btl/actions/action_axpy.hh
Normal file
@@ -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 ):_coef(1.0),_size(size)
|
||||
{
|
||||
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
|
||||
128
cs440-acg/ext/eigen/bench/btl/actions/action_cholesky.hh
Normal file
128
cs440-acg/ext/eigen/bench/btl/actions/action_cholesky.hh
Normal file
@@ -0,0 +1,128 @@
|
||||
//=====================================================
|
||||
// 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 "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
|
||||
128
cs440-acg/ext/eigen/bench/btl/actions/action_ger.hh
Normal file
128
cs440-acg/ext/eigen/bench/btl/actions/action_ger.hh
Normal file
@@ -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
|
||||
233
cs440-acg/ext/eigen/bench/btl/actions/action_hessenberg.hh
Normal file
233
cs440-acg/ext/eigen/bench/btl/actions/action_hessenberg.hh
Normal file
@@ -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
|
||||
124
cs440-acg/ext/eigen/bench/btl/actions/action_lu_decomp.hh
Normal file
124
cs440-acg/ext/eigen/bench/btl/actions/action_lu_decomp.hh
Normal file
@@ -0,0 +1,124 @@
|
||||
//=====================================================
|
||||
// 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);
|
||||
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 = 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 "complete_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 ){
|
||||
// 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::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
|
||||
136
cs440-acg/ext/eigen/bench/btl/actions/action_lu_solve.hh
Normal file
136
cs440-acg/ext/eigen/bench/btl/actions/action_lu_solve.hh
Normal file
@@ -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
|
||||
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
|
||||
125
cs440-acg/ext/eigen/bench/btl/actions/action_partial_lu.hh
Normal file
125
cs440-acg/ext/eigen/bench/btl/actions/action_partial_lu.hh
Normal file
@@ -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
|
||||
116
cs440-acg/ext/eigen/bench/btl/actions/action_rot.hh
Normal file
116
cs440-acg/ext/eigen/bench/btl/actions/action_rot.hh
Normal file
@@ -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
|
||||
139
cs440-acg/ext/eigen/bench/btl/actions/action_symv.hh
Normal file
139
cs440-acg/ext/eigen/bench/btl/actions/action_symv.hh
Normal file
@@ -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
|
||||
133
cs440-acg/ext/eigen/bench/btl/actions/action_syr2.hh
Normal file
133
cs440-acg/ext/eigen/bench/btl/actions/action_syr2.hh
Normal file
@@ -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
|
||||
137
cs440-acg/ext/eigen/bench/btl/actions/action_trisolve.hh
Normal file
137
cs440-acg/ext/eigen/bench/btl/actions/action_trisolve.hh
Normal file
@@ -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
|
||||
165
cs440-acg/ext/eigen/bench/btl/actions/action_trisolve_matrix.hh
Normal file
165
cs440-acg/ext/eigen/bench/btl/actions/action_trisolve_matrix.hh
Normal file
@@ -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
|
||||
|
||||
|
||||
|
||||
165
cs440-acg/ext/eigen/bench/btl/actions/action_trmm.hh
Normal file
165
cs440-acg/ext/eigen/bench/btl/actions/action_trmm.hh
Normal file
@@ -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
|
||||
|
||||
|
||||
|
||||
21
cs440-acg/ext/eigen/bench/btl/actions/basic_actions.hh
Normal file
21
cs440-acg/ext/eigen/bench/btl/actions/basic_actions.hh
Normal file
@@ -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"
|
||||
|
||||
32
cs440-acg/ext/eigen/bench/btl/data/CMakeLists.txt
Normal file
32
cs440-acg/ext/eigen/bench/btl/data/CMakeLists.txt
Normal file
@@ -0,0 +1,32 @@
|
||||
|
||||
ADD_CUSTOM_TARGET(copy_scripts)
|
||||
|
||||
SET(script_files go_mean mk_mean_script.sh mk_new_gnuplot.sh
|
||||
perlib_plot_settings.txt action_settings.txt gnuplot_common_settings.hh )
|
||||
|
||||
FOREACH(script_file ${script_files})
|
||||
ADD_CUSTOM_COMMAND(
|
||||
TARGET copy_scripts
|
||||
POST_BUILD
|
||||
COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/${script_file} ${CMAKE_CURRENT_BINARY_DIR}/
|
||||
ARGS
|
||||
)
|
||||
ENDFOREACH(script_file)
|
||||
|
||||
ADD_CUSTOM_COMMAND(
|
||||
TARGET copy_scripts
|
||||
POST_BUILD
|
||||
COMMAND ${CMAKE_CXX_COMPILER} --version | head -n 1 > ${CMAKE_CURRENT_BINARY_DIR}/compiler_version.txt
|
||||
ARGS
|
||||
)
|
||||
ADD_CUSTOM_COMMAND(
|
||||
TARGET copy_scripts
|
||||
POST_BUILD
|
||||
COMMAND echo "${Eigen_SOURCE_DIR}" > ${CMAKE_CURRENT_BINARY_DIR}/eigen_root_dir.txt
|
||||
ARGS
|
||||
)
|
||||
|
||||
add_executable(smooth smooth.cxx)
|
||||
add_executable(regularize regularize.cxx)
|
||||
add_executable(main mean.cxx)
|
||||
add_dependencies(main copy_scripts)
|
||||
19
cs440-acg/ext/eigen/bench/btl/data/action_settings.txt
Normal file
19
cs440-acg/ext/eigen/bench/btl/data/action_settings.txt
Normal file
@@ -0,0 +1,19 @@
|
||||
aat ; "{/*1.5 A x A^T}" ; "matrix size" ; 4:5000
|
||||
ata ; "{/*1.5 A^T x A}" ; "matrix size" ; 4:5000
|
||||
atv ; "{/*1.5 matrix^T x vector}" ; "matrix size" ; 4:5000
|
||||
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:5000
|
||||
matrix_vector ; "{/*1.5 matrix vector product}" ; "matrix size" ; 4:5000
|
||||
trmm ; "{/*1.5 triangular matrix matrix product}" ; "matrix size" ; 4:5000
|
||||
trisolve_vector ; "{/*1.5 triangular solver - vector (X = inv(L) X)}" ; "size" ; 4:5000
|
||||
trisolve_matrix ; "{/*1.5 triangular solver - matrix (M = inv(L) M)}" ; "size" ; 4:5000
|
||||
cholesky ; "{/*1.5 Cholesky decomposition}" ; "matrix size" ; 4:5000
|
||||
complete_lu_decomp ; "{/*1.5 Complete LU decomposition}" ; "matrix size" ; 4:5000
|
||||
partial_lu_decomp ; "{/*1.5 Partial LU decomposition}" ; "matrix size" ; 4:5000
|
||||
tridiagonalization ; "{/*1.5 Tridiagonalization}" ; "matrix size" ; 4:5000
|
||||
hessenberg ; "{/*1.5 Hessenberg decomposition}" ; "matrix size" ; 4:5000
|
||||
symv ; "{/*1.5 symmetric matrix vector product}" ; "matrix size" ; 4:5000
|
||||
syr2 ; "{/*1.5 symmretric rank-2 update (A += u^T v + u v^T)}" ; "matrix size" ; 4:5000
|
||||
ger ; "{/*1.5 general rank-1 update (A += u v^T)}" ; "matrix size" ; 4:5000
|
||||
rot ; "{/*1.5 apply rotation in the plane}" ; "vector size" ; 4:1000000
|
||||
@@ -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]
|
||||
|
||||
58
cs440-acg/ext/eigen/bench/btl/data/go_mean
Executable file
58
cs440-acg/ext/eigen/bench/btl/data/go_mean
Executable file
@@ -0,0 +1,58 @@
|
||||
#!/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 trmm $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
|
||||
182
cs440-acg/ext/eigen/bench/btl/data/mean.cxx
Normal file
182
cs440-acg/ext/eigen/bench/btl/data/mean.cxx
Normal file
@@ -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;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
68
cs440-acg/ext/eigen/bench/btl/data/mk_gnuplot_script.sh
Normal file
68
cs440-acg/ext/eigen/bench/btl/data/mk_gnuplot_script.sh
Normal file
@@ -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
|
||||
|
||||
|
||||
|
||||
|
||||
52
cs440-acg/ext/eigen/bench/btl/data/mk_mean_script.sh
Normal file
52
cs440-acg/ext/eigen/bench/btl/data/mk_mean_script.sh
Normal file
@@ -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
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
54
cs440-acg/ext/eigen/bench/btl/data/mk_new_gnuplot.sh
Executable file
54
cs440-acg/ext/eigen/bench/btl/data/mk_new_gnuplot.sh
Executable file
@@ -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
|
||||
16
cs440-acg/ext/eigen/bench/btl/data/perlib_plot_settings.txt
Normal file
16
cs440-acg/ext/eigen/bench/btl/data/perlib_plot_settings.txt
Normal file
@@ -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"
|
||||
OPENBLAS ; 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"
|
||||
blaze ; with lines lw 3 lt 1 lc rgbcolor "#ff00ff"
|
||||
131
cs440-acg/ext/eigen/bench/btl/data/regularize.cxx
Normal file
131
cs440-acg/ext/eigen/bench/btl/data/regularize.cxx
Normal file
@@ -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();
|
||||
}
|
||||
|
||||
198
cs440-acg/ext/eigen/bench/btl/data/smooth.cxx
Normal file
198
cs440-acg/ext/eigen/bench/btl/data/smooth.cxx
Normal file
@@ -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();
|
||||
}
|
||||
|
||||
68
cs440-acg/ext/eigen/bench/btl/data/smooth_all.sh
Executable file
68
cs440-acg/ext/eigen/bench/btl/data/smooth_all.sh
Executable file
@@ -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
|
||||
168
cs440-acg/ext/eigen/bench/btl/generic_bench/bench.hh
Normal file
168
cs440-acg/ext/eigen/bench/btl/generic_bench/bench.hh
Normal file
@@ -0,0 +1,168 @@
|
||||
//=====================================================
|
||||
// File : bench.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_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"
|
||||
// #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
|
||||
using namespace std;
|
||||
|
||||
template <template<class> class Perf_Analyzer, class Action>
|
||||
BTL_DONT_INLINE void bench( int size_min, int size_max, int nb_point )
|
||||
{
|
||||
if (BtlConfig::skipAction(Action::name()))
|
||||
return;
|
||||
|
||||
string filename="bench_"+Action::name()+".dat";
|
||||
|
||||
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);
|
||||
|
||||
std::vector<int> oldSizes;
|
||||
std::vector<double> oldFlops;
|
||||
bool hasOldResults = read_xy_file(filename, oldSizes, oldFlops, true);
|
||||
int oldi = oldSizes.size() - 1;
|
||||
|
||||
// loop on matrix size
|
||||
Perf_Analyzer<Action> perf_action;
|
||||
for (int i=nb_point-1;i>=0;i--)
|
||||
{
|
||||
//INFOS("size=" <<tab_sizes[i]<<" ("<<nb_point-i<<"/"<<nb_point<<")");
|
||||
std::cout << " " << "size = " << tab_sizes[i] << " " << std::flush;
|
||||
|
||||
BTL_DISABLE_SSE_EXCEPTIONS();
|
||||
#ifdef HAVE_MKL
|
||||
{
|
||||
float dummy;
|
||||
cblas_saxpy(1,0,&dummy,1,&dummy,1);
|
||||
}
|
||||
#endif
|
||||
|
||||
tab_mflops[i] = perf_action.eval_mflops(tab_sizes[i]);
|
||||
std::cout << tab_mflops[i];
|
||||
|
||||
if (hasOldResults)
|
||||
{
|
||||
while (oldi>=0 && oldSizes[oldi]>tab_sizes[i])
|
||||
--oldi;
|
||||
if (oldi>=0 && oldSizes[oldi]==tab_sizes[i])
|
||||
{
|
||||
if (oldFlops[oldi]<tab_mflops[i])
|
||||
std::cout << "\t > ";
|
||||
else
|
||||
std::cout << "\t < ";
|
||||
std::cout << oldFlops[oldi];
|
||||
}
|
||||
--oldi;
|
||||
}
|
||||
std::cout << " MFlops (" << nb_point-i << "/" << nb_point << ")" << std::endl;
|
||||
}
|
||||
|
||||
if (!BtlConfig::Instance.overwriteResults)
|
||||
{
|
||||
if (hasOldResults)
|
||||
{
|
||||
// merge the two data
|
||||
std::vector<int> newSizes;
|
||||
std::vector<double> newFlops;
|
||||
unsigned int i=0;
|
||||
unsigned int j=0;
|
||||
while (i<tab_sizes.size() && j<oldSizes.size())
|
||||
{
|
||||
if (tab_sizes[i] == oldSizes[j])
|
||||
{
|
||||
newSizes.push_back(tab_sizes[i]);
|
||||
newFlops.push_back(std::max(tab_mflops[i], oldFlops[j]));
|
||||
++i;
|
||||
++j;
|
||||
}
|
||||
else if (tab_sizes[i] < oldSizes[j])
|
||||
{
|
||||
newSizes.push_back(tab_sizes[i]);
|
||||
newFlops.push_back(tab_mflops[i]);
|
||||
++i;
|
||||
}
|
||||
else
|
||||
{
|
||||
newSizes.push_back(oldSizes[j]);
|
||||
newFlops.push_back(oldFlops[j]);
|
||||
++j;
|
||||
}
|
||||
}
|
||||
while (i<tab_sizes.size())
|
||||
{
|
||||
newSizes.push_back(tab_sizes[i]);
|
||||
newFlops.push_back(tab_mflops[i]);
|
||||
++i;
|
||||
}
|
||||
while (j<oldSizes.size())
|
||||
{
|
||||
newSizes.push_back(oldSizes[j]);
|
||||
newFlops.push_back(oldFlops[j]);
|
||||
++j;
|
||||
}
|
||||
tab_mflops = newFlops;
|
||||
tab_sizes = newSizes;
|
||||
}
|
||||
}
|
||||
|
||||
// dump the result in a file :
|
||||
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 ){
|
||||
|
||||
// if the rdtsc is not available :
|
||||
bench<Portable_Perf_Analyzer,Action>(size_min,size_max,nb_point);
|
||||
// if the rdtsc is available :
|
||||
// bench<Mixed_Perf_Analyzer,Action>(size_min,size_max,nb_point);
|
||||
|
||||
|
||||
// Only for small problem size. Otherwize it will be too long
|
||||
// bench<X86_Perf_Analyzer,Action>(size_min,size_max,nb_point);
|
||||
// bench<STL_Perf_Analyzer,Action>(size_min,size_max,nb_point);
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -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 3000000
|
||||
// min matrix size for matrix vector product bench
|
||||
#define MIN_MV 5
|
||||
// max matrix size for matrix vector product bench
|
||||
#define MAX_MV 5000
|
||||
// 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
|
||||
242
cs440-acg/ext/eigen/bench/btl/generic_bench/btl.hh
Normal file
242
cs440-acg/ext/eigen/bench/btl/generic_bench/btl.hh
Normal file
@@ -0,0 +1,242 @@
|
||||
//=====================================================
|
||||
// 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
|
||||
|
||||
#ifdef __SSE__
|
||||
#include "xmmintrin.h"
|
||||
// This enables flush to zero (FTZ) and denormals are zero (DAZ) modes:
|
||||
#define BTL_DISABLE_SSE_EXCEPTIONS() { _mm_setcsr(_mm_getcsr() | 0x8040); }
|
||||
#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 (unsigned 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 (unsigned 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
|
||||
@@ -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
|
||||
@@ -0,0 +1,64 @@
|
||||
//=====================================================
|
||||
// File : init_matrix.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 INIT_MATRIX_HH
|
||||
#define INIT_MATRIX_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 (unsigned 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 (unsigned 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 (unsigned int row=0; row<A.size() ; row++)
|
||||
A[row].resize(size);
|
||||
for (unsigned int row=0; row<A.size() ; row++){
|
||||
A[row][row] = init_function(row,row);
|
||||
for (unsigned int col=0; col<row ; col++){
|
||||
double x = init_function(row,col);
|
||||
A[row][col] = A[col][row] = x;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -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 (unsigned int i=0;i<X.size();i++){
|
||||
X[i]=typename Vector::value_type(init_function(i));
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -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
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -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
|
||||
@@ -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
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -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
|
||||
@@ -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;
|
||||
};
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,103 @@
|
||||
//=====================================================
|
||||
// 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>
|
||||
//=====================================================
|
||||
//
|
||||
// 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( ):_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)
|
||||
{
|
||||
Action action(size);
|
||||
|
||||
// action.initialize();
|
||||
// time_action = time_calculate(action);
|
||||
while (m_time_action < MIN_TIME)
|
||||
{
|
||||
if(_nb_calc==0) _nb_calc = 1;
|
||||
else _nb_calc *= 2;
|
||||
action.initialize();
|
||||
m_time_action = time_calculate(action);
|
||||
}
|
||||
|
||||
// optimize
|
||||
for (int i=1; i<BtlConfig::Instance.tries; ++i)
|
||||
{
|
||||
Action _action(size);
|
||||
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 (unsigned int ii=0;ii<_nb_calc;ii++)
|
||||
{
|
||||
action.calculate();
|
||||
}
|
||||
_chronos.stop();
|
||||
return _chronos.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
|
||||
|
||||
@@ -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
|
||||
187
cs440-acg/ext/eigen/bench/btl/generic_bench/timers/portable_timer.hh
Executable file
187
cs440-acg/ext/eigen/bench/btl/generic_bench/timers/portable_timer.hh
Executable file
@@ -0,0 +1,187 @@
|
||||
//=====================================================
|
||||
// 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.
|
||||
#if defined(_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
|
||||
|
||||
#elif defined(__APPLE__)
|
||||
#include <CoreServices/CoreServices.h>
|
||||
#include <mach/mach_time.h>
|
||||
|
||||
|
||||
class Portable_Timer
|
||||
{
|
||||
public:
|
||||
|
||||
Portable_Timer()
|
||||
{
|
||||
}
|
||||
|
||||
void start()
|
||||
{
|
||||
m_start_time = double(mach_absolute_time())*1e-9;;
|
||||
|
||||
}
|
||||
|
||||
void stop()
|
||||
{
|
||||
m_stop_time = double(mach_absolute_time())*1e-9;;
|
||||
|
||||
}
|
||||
|
||||
double elapsed()
|
||||
{
|
||||
return user_time();
|
||||
}
|
||||
|
||||
double user_time()
|
||||
{
|
||||
return m_stop_time - m_start_time;
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
double m_stop_time, m_start_time;
|
||||
|
||||
}; // Portable_Timer (Apple)
|
||||
|
||||
#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 (Linux)
|
||||
|
||||
#endif
|
||||
|
||||
#endif // PORTABLE_TIMER_HPP
|
||||
@@ -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
|
||||
246
cs440-acg/ext/eigen/bench/btl/generic_bench/timers/x86_timer.hh
Normal file
246
cs440-acg/ext/eigen/bench/btl/generic_bench/timers/x86_timer.hh
Normal file
@@ -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
|
||||
@@ -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+1;
|
||||
|
||||
}
|
||||
|
||||
Vector log_size;
|
||||
size_log(nb_point-nine,ten,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
|
||||
|
||||
|
||||
|
||||
@@ -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
|
||||
@@ -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 */
|
||||
75
cs440-acg/ext/eigen/bench/btl/generic_bench/utils/xy_file.hh
Normal file
75
cs440-acg/ext/eigen/bench/btl/generic_bench/utils/xy_file.hh
Normal file
@@ -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
|
||||
47
cs440-acg/ext/eigen/bench/btl/libs/BLAS/CMakeLists.txt
Normal file
47
cs440-acg/ext/eigen/bench/btl/libs/BLAS/CMakeLists.txt
Normal file
@@ -0,0 +1,47 @@
|
||||
|
||||
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(OPENBLAS)
|
||||
if (OPENBLAS_FOUND)
|
||||
btl_add_bench(btl_openblas main.cpp)
|
||||
if(BUILD_btl_openblas)
|
||||
target_link_libraries(btl_openblas ${OPENBLAS_LIBRARIES} )
|
||||
set_target_properties(btl_openblas PROPERTIES COMPILE_FLAGS "-DCBLASNAME=OPENBLAS")
|
||||
endif(BUILD_btl_openblas)
|
||||
endif (OPENBLAS_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()
|
||||
675
cs440-acg/ext/eigen/bench/btl/libs/BLAS/blas.h
Normal file
675
cs440-acg/ext/eigen/bench/btl/libs/BLAS/blas.h
Normal file
@@ -0,0 +1,675 @@
|
||||
#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
|
||||
|
||||
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
|
||||
83
cs440-acg/ext/eigen/bench/btl/libs/BLAS/blas_interface.hh
Normal file
83
cs440-acg/ext/eigen/bench/btl/libs/BLAS/blas_interface.hh
Normal file
@@ -0,0 +1,83 @@
|
||||
//=====================================================
|
||||
// File : blas_interface.hh
|
||||
// Author : L. Plagne <laurent.plagne@edf.fr)>
|
||||
// Copyright (C) EDF R&D, lun sep 30 14:23:28 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 blas_PRODUIT_MATRICE_VECTEUR_HH
|
||||
#define blas_PRODUIT_MATRICE_VECTEUR_HH
|
||||
|
||||
#include <c_interface_base.h>
|
||||
#include <complex>
|
||||
extern "C"
|
||||
{
|
||||
#include "blas.h"
|
||||
|
||||
// Cholesky Factorization
|
||||
// void spotrf_(const char* uplo, const int* n, float *a, const int* ld, int* info);
|
||||
// void dpotrf_(const char* uplo, const int* n, double *a, const int* ld, int* info);
|
||||
void ssytrd_(char *uplo, const int *n, float *a, const int *lda, float *d, float *e, float *tau, float *work, int *lwork, int *info );
|
||||
void dsytrd_(char *uplo, const int *n, double *a, const int *lda, double *d, double *e, double *tau, double *work, int *lwork, int *info );
|
||||
void sgehrd_( const int *n, int *ilo, int *ihi, float *a, const int *lda, float *tau, float *work, int *lwork, int *info );
|
||||
void dgehrd_( const int *n, int *ilo, int *ihi, double *a, const int *lda, double *tau, double *work, int *lwork, int *info );
|
||||
|
||||
// LU row pivoting
|
||||
// void dgetrf_( int *m, int *n, double *a, int *lda, int *ipiv, int *info );
|
||||
// void sgetrf_(const int* m, const int* n, float *a, const int* ld, int* ipivot, int* info);
|
||||
// LU full pivoting
|
||||
void sgetc2_(const int* n, float *a, const int *lda, int *ipiv, int *jpiv, int*info );
|
||||
void dgetc2_(const int* n, double *a, const int *lda, int *ipiv, int *jpiv, int*info );
|
||||
#ifdef HAS_LAPACK
|
||||
#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
|
||||
#include "blas_interface_impl.hh"
|
||||
#undef SCALAR
|
||||
#undef SCALAR_PREFIX
|
||||
|
||||
|
||||
#define SCALAR double
|
||||
#define SCALAR_PREFIX d
|
||||
#include "blas_interface_impl.hh"
|
||||
#undef SCALAR
|
||||
#undef SCALAR_PREFIX
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
147
cs440-acg/ext/eigen/bench/btl/libs/BLAS/blas_interface_impl.hh
Normal file
147
cs440-acg/ext/eigen/bench/btl/libs/BLAS/blas_interface_impl.hh
Normal file
@@ -0,0 +1,147 @@
|
||||
|
||||
#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 ata_product(gene_matrix & A, gene_matrix & X, int N){
|
||||
// ssyrk_(&lower,&trans,&N,&N,&fone,A,&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 cholesky(const gene_matrix & X, gene_matrix & C, int N){
|
||||
int N2 = N*N;
|
||||
BLAS_FUNC(copy)(&N2, X, &intone, C, &intone);
|
||||
char uplo = 'L';
|
||||
int info = 0;
|
||||
BLAS_FUNC(potrf)(&uplo, &N, C, &N, &info);
|
||||
if(info!=0) std::cerr << "potrf_ error " << info << "\n";
|
||||
}
|
||||
|
||||
static inline void partial_lu_decomp(const gene_matrix & X, gene_matrix & C, int N){
|
||||
int N2 = N*N;
|
||||
BLAS_FUNC(copy)(&N2, X, &intone, C, &intone);
|
||||
int info = 0;
|
||||
int * ipiv = (int*)alloca(sizeof(int)*N);
|
||||
BLAS_FUNC(getrf)(&N, &N, C, &N, ipiv, &info);
|
||||
if(info!=0) std::cerr << "getrf_ error " << info << "\n";
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
#ifdef HAS_LAPACK
|
||||
|
||||
static inline void lu_decomp(const gene_matrix & X, gene_matrix & C, int N){
|
||||
int N2 = N*N;
|
||||
BLAS_FUNC(copy)(&N2, X, &intone, C, &intone);
|
||||
int info = 0;
|
||||
int * ipiv = (int*)alloca(sizeof(int)*N);
|
||||
int * jpiv = (int*)alloca(sizeof(int)*N);
|
||||
BLAS_FUNC(getc2)(&N, C, &N, ipiv, jpiv, &info);
|
||||
}
|
||||
|
||||
|
||||
|
||||
static inline void hessenberg(const gene_matrix & X, gene_matrix & C, int N){
|
||||
{
|
||||
int N2 = N*N;
|
||||
int inc = 1;
|
||||
BLAS_FUNC(copy)(&N2, X, &inc, C, &inc);
|
||||
}
|
||||
int info = 0;
|
||||
int ilo = 1;
|
||||
int ihi = N;
|
||||
int bsize = 64;
|
||||
int worksize = N*bsize;
|
||||
SCALAR* d = new SCALAR[N+worksize];
|
||||
BLAS_FUNC(gehrd)(&N, &ilo, &ihi, C, &N, d, d+N, &worksize, &info);
|
||||
delete[] d;
|
||||
}
|
||||
|
||||
static inline void tridiagonalization(const gene_matrix & X, gene_matrix & C, int N){
|
||||
{
|
||||
int N2 = N*N;
|
||||
int inc = 1;
|
||||
BLAS_FUNC(copy)(&N2, X, &inc, C, &inc);
|
||||
}
|
||||
char uplo = 'U';
|
||||
int info = 0;
|
||||
int bsize = 64;
|
||||
int worksize = N*bsize;
|
||||
SCALAR* d = new SCALAR[3*N+worksize];
|
||||
BLAS_FUNC(sytrd)(&uplo, &N, C, &N, d, d+N, d+2*N, d+3*N, &worksize, &info);
|
||||
delete[] d;
|
||||
}
|
||||
|
||||
#endif // HAS_LAPACK
|
||||
|
||||
};
|
||||
|
||||
SCALAR blas_interface<SCALAR>::fone = SCALAR(1);
|
||||
SCALAR blas_interface<SCALAR>::fzero = SCALAR(0);
|
||||
73
cs440-acg/ext/eigen/bench/btl/libs/BLAS/c_interface_base.h
Normal file
73
cs440-acg/ext/eigen/bench/btl/libs/BLAS/c_interface_base.h
Normal file
@@ -0,0 +1,73 @@
|
||||
|
||||
#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
|
||||
73
cs440-acg/ext/eigen/bench/btl/libs/BLAS/main.cpp
Normal file
73
cs440-acg/ext/eigen/bench/btl/libs/BLAS/main.cpp
Normal file
@@ -0,0 +1,73 @@
|
||||
//=====================================================
|
||||
// File : main.cpp
|
||||
// Author : L. Plagne <laurent.plagne@edf.fr)>
|
||||
// Copyright (C) EDF R&D, lun sep 30 14:23:28 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 "blas_interface.hh"
|
||||
#include "bench.hh"
|
||||
#include "basic_actions.hh"
|
||||
|
||||
#include "action_cholesky.hh"
|
||||
#include "action_lu_decomp.hh"
|
||||
#include "action_partial_lu.hh"
|
||||
#include "action_trisolve_matrix.hh"
|
||||
|
||||
#ifdef HAS_LAPACK
|
||||
#include "action_hessenberg.hh"
|
||||
#endif
|
||||
|
||||
BTL_MAIN;
|
||||
|
||||
int main()
|
||||
{
|
||||
|
||||
bench<Action_axpy<blas_interface<REAL_TYPE> > >(MIN_AXPY,MAX_AXPY,NB_POINT);
|
||||
bench<Action_axpby<blas_interface<REAL_TYPE> > >(MIN_AXPY,MAX_AXPY,NB_POINT);
|
||||
|
||||
bench<Action_matrix_vector_product<blas_interface<REAL_TYPE> > >(MIN_MV,MAX_MV,NB_POINT);
|
||||
bench<Action_atv_product<blas_interface<REAL_TYPE> > >(MIN_MV,MAX_MV,NB_POINT);
|
||||
bench<Action_symv<blas_interface<REAL_TYPE> > >(MIN_MV,MAX_MV,NB_POINT);
|
||||
bench<Action_syr2<blas_interface<REAL_TYPE> > >(MIN_MV,MAX_MV,NB_POINT);
|
||||
|
||||
bench<Action_ger<blas_interface<REAL_TYPE> > >(MIN_MV,MAX_MV,NB_POINT);
|
||||
bench<Action_rot<blas_interface<REAL_TYPE> > >(MIN_AXPY,MAX_AXPY,NB_POINT);
|
||||
|
||||
bench<Action_matrix_matrix_product<blas_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
// bench<Action_ata_product<blas_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
bench<Action_aat_product<blas_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
|
||||
bench<Action_trisolve<blas_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
bench<Action_trisolve_matrix<blas_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
|
||||
bench<Action_trmm<blas_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
|
||||
bench<Action_cholesky<blas_interface<REAL_TYPE> > >(MIN_LU,MAX_LU,NB_POINT);
|
||||
bench<Action_partial_lu<blas_interface<REAL_TYPE> > >(MIN_LU,MAX_LU,NB_POINT);
|
||||
|
||||
#ifdef HAS_LAPACK
|
||||
// bench<Action_lu_decomp<blas_interface<REAL_TYPE> > >(MIN_LU,MAX_LU,NB_POINT);
|
||||
bench<Action_hessenberg<blas_interface<REAL_TYPE> > >(MIN_LU,MAX_LU,NB_POINT);
|
||||
bench<Action_tridiagonalization<blas_interface<REAL_TYPE> > >(MIN_LU,MAX_LU,NB_POINT);
|
||||
#endif
|
||||
|
||||
//bench<Action_lu_solve<blas_LU_solve_interface<REAL_TYPE> > >(MIN_LU,MAX_LU,NB_POINT);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
2
cs440-acg/ext/eigen/bench/btl/libs/STL/CMakeLists.txt
Normal file
2
cs440-acg/ext/eigen/bench/btl/libs/STL/CMakeLists.txt
Normal file
@@ -0,0 +1,2 @@
|
||||
|
||||
btl_add_bench(btl_STL main.cpp OFF)
|
||||
244
cs440-acg/ext/eigen/bench/btl/libs/STL/STL_interface.hh
Normal file
244
cs440-acg/ext/eigen/bench/btl/libs/STL/STL_interface.hh
Normal file
@@ -0,0 +1,244 @@
|
||||
//=====================================================
|
||||
// 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 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
|
||||
42
cs440-acg/ext/eigen/bench/btl/libs/STL/main.cpp
Normal file
42
cs440-acg/ext/eigen/bench/btl/libs/STL/main.cpp
Normal file
@@ -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;
|
||||
}
|
||||
|
||||
|
||||
13
cs440-acg/ext/eigen/bench/btl/libs/blaze/CMakeLists.txt
Normal file
13
cs440-acg/ext/eigen/bench/btl/libs/blaze/CMakeLists.txt
Normal file
@@ -0,0 +1,13 @@
|
||||
|
||||
find_package(BLAZE)
|
||||
find_package(Boost COMPONENTS system)
|
||||
if (BLAZE_FOUND AND Boost_FOUND)
|
||||
include_directories(${BLAZE_INCLUDE_DIR} ${Boost_INCLUDE_DIRS})
|
||||
btl_add_bench(btl_blaze main.cpp)
|
||||
# Note: The newest blaze version requires C++14.
|
||||
# Ideally, we should set this depending on the version of Blaze we found
|
||||
set_property(TARGET btl_blaze PROPERTY CXX_STANDARD 14)
|
||||
if(BUILD_btl_blaze)
|
||||
target_link_libraries(btl_blaze ${Boost_LIBRARIES})
|
||||
endif()
|
||||
endif ()
|
||||
140
cs440-acg/ext/eigen/bench/btl/libs/blaze/blaze_interface.hh
Normal file
140
cs440-acg/ext/eigen/bench/btl/libs/blaze/blaze_interface.hh
Normal file
@@ -0,0 +1,140 @@
|
||||
//=====================================================
|
||||
// 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 BLAZE_INTERFACE_HH
|
||||
#define BLAZE_INTERFACE_HH
|
||||
|
||||
#include <blaze/Math.h>
|
||||
#include <blaze/Blaze.h>
|
||||
// using namespace blaze;
|
||||
|
||||
#include <vector>
|
||||
|
||||
template<class real>
|
||||
class blaze_interface {
|
||||
|
||||
public :
|
||||
|
||||
typedef real real_type ;
|
||||
|
||||
typedef std::vector<real> stl_vector;
|
||||
typedef std::vector<stl_vector > stl_matrix;
|
||||
|
||||
typedef blaze::DynamicMatrix<real,blaze::columnMajor> gene_matrix;
|
||||
typedef blaze::DynamicVector<real> gene_vector;
|
||||
|
||||
static inline std::string name() { return "blaze"; }
|
||||
|
||||
static void free_matrix(gene_matrix & A, int N){
|
||||
return ;
|
||||
}
|
||||
|
||||
static void free_vector(gene_vector & B){
|
||||
return ;
|
||||
}
|
||||
|
||||
static inline void matrix_from_stl(gene_matrix & A, stl_matrix & A_stl){
|
||||
A.resize(A_stl[0].size(), A_stl.size());
|
||||
|
||||
for (int j=0; j<A_stl.size() ; j++){
|
||||
for (int i=0; i<A_stl[j].size() ; i++){
|
||||
A(i,j) = A_stl[j][i];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static inline void vector_from_stl(gene_vector & B, stl_vector & B_stl){
|
||||
B.resize(B_stl.size());
|
||||
for (int i=0; i<B_stl.size() ; i++){
|
||||
B[i] = B_stl[i];
|
||||
}
|
||||
}
|
||||
|
||||
static inline void vector_to_stl(gene_vector & B, stl_vector & B_stl){
|
||||
for (int i=0; i<B_stl.size() ; 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,j);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static inline void matrix_matrix_product(const gene_matrix & A, const gene_matrix & B, gene_matrix & X, int N){
|
||||
X = (A*B);
|
||||
}
|
||||
|
||||
static inline void transposed_matrix_matrix_product(const gene_matrix & A, const gene_matrix & B, gene_matrix & X, int N){
|
||||
X = (trans(A)*trans(B));
|
||||
}
|
||||
|
||||
static inline void ata_product(const gene_matrix & A, gene_matrix & X, int N){
|
||||
X = (trans(A)*A);
|
||||
}
|
||||
|
||||
static inline void aat_product(const gene_matrix & A, gene_matrix & X, int N){
|
||||
X = (A*trans(A));
|
||||
}
|
||||
|
||||
static inline void matrix_vector_product(gene_matrix & A, gene_vector & B, gene_vector & X, int N){
|
||||
X = (A*B);
|
||||
}
|
||||
|
||||
static inline void atv_product(gene_matrix & A, gene_vector & B, gene_vector & X, int N){
|
||||
X = (trans(A)*B);
|
||||
}
|
||||
|
||||
static inline void axpy(const real coef, const gene_vector & X, gene_vector & Y, int N){
|
||||
Y += coef * X;
|
||||
}
|
||||
|
||||
static inline void axpby(real a, const gene_vector & X, real b, gene_vector & Y, int N){
|
||||
Y = a*X + b*Y;
|
||||
}
|
||||
|
||||
// static inline void cholesky(const gene_matrix & X, gene_matrix & C, int N){
|
||||
// C = X;
|
||||
// recursive_cholesky(C);
|
||||
// }
|
||||
|
||||
// static inline void lu_decomp(const gene_matrix & X, gene_matrix & R, int N){
|
||||
// R = X;
|
||||
// std::vector<int> ipvt(N);
|
||||
// lu_factor(R, ipvt);
|
||||
// }
|
||||
|
||||
// static inline void trisolve_lower(const gene_matrix & L, const gene_vector& B, gene_vector & X, int N){
|
||||
// X = lower_trisolve(L, B);
|
||||
// }
|
||||
|
||||
static inline void copy_matrix(const gene_matrix & source, gene_matrix & cible, int N){
|
||||
cible = source;
|
||||
}
|
||||
|
||||
static inline void copy_vector(const gene_vector & source, gene_vector & cible, int N){
|
||||
cible = source;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif
|
||||
40
cs440-acg/ext/eigen/bench/btl/libs/blaze/main.cpp
Normal file
40
cs440-acg/ext/eigen/bench/btl/libs/blaze/main.cpp
Normal file
@@ -0,0 +1,40 @@
|
||||
//=====================================================
|
||||
// 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.
|
||||
//
|
||||
#include "utilities.h"
|
||||
#include "blaze_interface.hh"
|
||||
#include "bench.hh"
|
||||
#include "basic_actions.hh"
|
||||
|
||||
BTL_MAIN;
|
||||
|
||||
int main()
|
||||
{
|
||||
|
||||
bench<Action_axpy<blaze_interface<REAL_TYPE> > >(MIN_AXPY,MAX_AXPY,NB_POINT);
|
||||
bench<Action_axpby<blaze_interface<REAL_TYPE> > >(MIN_AXPY,MAX_AXPY,NB_POINT);
|
||||
|
||||
bench<Action_matrix_vector_product<blaze_interface<REAL_TYPE> > >(MIN_MV,MAX_MV,NB_POINT);
|
||||
bench<Action_atv_product<blaze_interface<REAL_TYPE> > >(MIN_MV,MAX_MV,NB_POINT);
|
||||
// bench<Action_matrix_matrix_product<blaze_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
// bench<Action_ata_product<blaze_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
// bench<Action_aat_product<blaze_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
17
cs440-acg/ext/eigen/bench/btl/libs/blitz/CMakeLists.txt
Normal file
17
cs440-acg/ext/eigen/bench/btl/libs/blitz/CMakeLists.txt
Normal file
@@ -0,0 +1,17 @@
|
||||
|
||||
find_package(Blitz)
|
||||
|
||||
if (BLITZ_FOUND)
|
||||
include_directories(${BLITZ_INCLUDES})
|
||||
|
||||
btl_add_bench(btl_blitz btl_blitz.cpp)
|
||||
if (BUILD_btl_blitz)
|
||||
target_link_libraries(btl_blitz ${BLITZ_LIBRARIES})
|
||||
endif (BUILD_btl_blitz)
|
||||
|
||||
btl_add_bench(btl_tiny_blitz btl_tiny_blitz.cpp OFF)
|
||||
if (BUILD_btl_tiny_blitz)
|
||||
target_link_libraries(btl_tiny_blitz ${BLITZ_LIBRARIES})
|
||||
endif (BUILD_btl_tiny_blitz)
|
||||
|
||||
endif (BLITZ_FOUND)
|
||||
@@ -0,0 +1,192 @@
|
||||
//=====================================================
|
||||
// File : blitz_LU_solve_interface.hh
|
||||
// Author : L. Plagne <laurent.plagne@edf.fr)>
|
||||
// Copyright (C) EDF R&D, lun sep 30 14:23:31 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 BLITZ_LU_SOLVE_INTERFACE_HH
|
||||
#define BLITZ_LU_SOLVE_INTERFACE_HH
|
||||
|
||||
#include "blitz/array.h"
|
||||
#include <vector>
|
||||
|
||||
BZ_USING_NAMESPACE(blitz)
|
||||
|
||||
template<class real>
|
||||
class blitz_LU_solve_interface : public blitz_interface<real>
|
||||
{
|
||||
|
||||
public :
|
||||
|
||||
typedef typename blitz_interface<real>::gene_matrix gene_matrix;
|
||||
typedef typename blitz_interface<real>::gene_vector gene_vector;
|
||||
|
||||
typedef blitz::Array<int,1> Pivot_Vector;
|
||||
|
||||
inline static void new_Pivot_Vector(Pivot_Vector & pivot,int N)
|
||||
{
|
||||
|
||||
pivot.resize(N);
|
||||
|
||||
}
|
||||
|
||||
inline static void free_Pivot_Vector(Pivot_Vector & pivot)
|
||||
{
|
||||
|
||||
return;
|
||||
|
||||
}
|
||||
|
||||
|
||||
static inline real matrix_vector_product_sliced(const gene_matrix & A, gene_vector B, int row, int col_start, int col_end)
|
||||
{
|
||||
|
||||
real somme=0.;
|
||||
|
||||
for (int j=col_start ; j<col_end+1 ; j++){
|
||||
|
||||
somme+=A(row,j)*B(j);
|
||||
|
||||
}
|
||||
|
||||
return somme;
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
static inline real matrix_matrix_product_sliced(gene_matrix & A, int row, int col_start, int col_end, gene_matrix & B, int row_shift, int col )
|
||||
{
|
||||
|
||||
real somme=0.;
|
||||
|
||||
for (int j=col_start ; j<col_end+1 ; j++){
|
||||
|
||||
somme+=A(row,j)*B(j+row_shift,col);
|
||||
|
||||
}
|
||||
|
||||
return somme;
|
||||
|
||||
}
|
||||
|
||||
inline static void LU_factor(gene_matrix & LU, Pivot_Vector & pivot, int N)
|
||||
{
|
||||
|
||||
ASSERT( LU.rows()==LU.cols() ) ;
|
||||
int index_max = 0 ;
|
||||
real big = 0. ;
|
||||
real theSum = 0. ;
|
||||
real dum = 0. ;
|
||||
// Get the implicit scaling information :
|
||||
gene_vector ImplicitScaling( N ) ;
|
||||
for( int i=0; i<N; i++ ) {
|
||||
big = 0. ;
|
||||
for( int j=0; j<N; j++ ) {
|
||||
if( abs( LU( i, j ) )>=big ) big = abs( LU( i, j ) ) ;
|
||||
}
|
||||
if( big==0. ) {
|
||||
INFOS( "blitz_LU_factor::Singular matrix" ) ;
|
||||
exit( 0 ) ;
|
||||
}
|
||||
ImplicitScaling( i ) = 1./big ;
|
||||
}
|
||||
// Loop over columns of Crout's method :
|
||||
for( int j=0; j<N; j++ ) {
|
||||
for( int i=0; i<j; i++ ) {
|
||||
theSum = LU( i, j ) ;
|
||||
theSum -= matrix_matrix_product_sliced(LU, i, 0, i-1, LU, 0, j) ;
|
||||
// theSum -= sum( LU( i, Range( fromStart, i-1 ) )*LU( Range( fromStart, i-1 ), j ) ) ;
|
||||
LU( i, j ) = theSum ;
|
||||
}
|
||||
|
||||
// Search for the largest pivot element :
|
||||
big = 0. ;
|
||||
for( int i=j; i<N; i++ ) {
|
||||
theSum = LU( i, j ) ;
|
||||
theSum -= matrix_matrix_product_sliced(LU, i, 0, j-1, LU, 0, j) ;
|
||||
// theSum -= sum( LU( i, Range( fromStart, j-1 ) )*LU( Range( fromStart, j-1 ), j ) ) ;
|
||||
LU( i, j ) = theSum ;
|
||||
if( (ImplicitScaling( i )*abs( theSum ))>=big ) {
|
||||
dum = ImplicitScaling( i )*abs( theSum ) ;
|
||||
big = dum ;
|
||||
index_max = i ;
|
||||
}
|
||||
}
|
||||
// Interchanging rows and the scale factor :
|
||||
if( j!=index_max ) {
|
||||
for( int k=0; k<N; k++ ) {
|
||||
dum = LU( index_max, k ) ;
|
||||
LU( index_max, k ) = LU( j, k ) ;
|
||||
LU( j, k ) = dum ;
|
||||
}
|
||||
ImplicitScaling( index_max ) = ImplicitScaling( j ) ;
|
||||
}
|
||||
pivot( j ) = index_max ;
|
||||
if ( LU( j, j )==0. ) LU( j, j ) = 1.e-20 ;
|
||||
// Divide by the pivot element :
|
||||
if( j<N ) {
|
||||
dum = 1./LU( j, j ) ;
|
||||
for( int i=j+1; i<N; i++ ) LU( i, j ) *= dum ;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
inline static void LU_solve(const gene_matrix & LU, const Pivot_Vector pivot, gene_vector &B, gene_vector X, int N)
|
||||
{
|
||||
|
||||
// Pour conserver le meme header, on travaille sur X, copie du second-membre B
|
||||
X = B.copy() ;
|
||||
ASSERT( LU.rows()==LU.cols() ) ;
|
||||
firstIndex indI ;
|
||||
// Forward substitution :
|
||||
int ii = 0 ;
|
||||
real theSum = 0. ;
|
||||
for( int i=0; i<N; i++ ) {
|
||||
int ip = pivot( i ) ;
|
||||
theSum = X( ip ) ;
|
||||
// theSum = B( ip ) ;
|
||||
X( ip ) = X( i ) ;
|
||||
// B( ip ) = B( i ) ;
|
||||
if( ii ) {
|
||||
theSum -= matrix_vector_product_sliced(LU, X, i, ii-1, i-1) ;
|
||||
// theSum -= sum( LU( i, Range( ii-1, i-1 ) )*X( Range( ii-1, i-1 ) ) ) ;
|
||||
// theSum -= sum( LU( i, Range( ii-1, i-1 ) )*B( Range( ii-1, i-1 ) ) ) ;
|
||||
} else if( theSum ) {
|
||||
ii = i+1 ;
|
||||
}
|
||||
X( i ) = theSum ;
|
||||
// B( i ) = theSum ;
|
||||
}
|
||||
// Backsubstitution :
|
||||
for( int i=N-1; i>=0; i-- ) {
|
||||
theSum = X( i ) ;
|
||||
// theSum = B( i ) ;
|
||||
theSum -= matrix_vector_product_sliced(LU, X, i, i+1, N) ;
|
||||
// theSum -= sum( LU( i, Range( i+1, toEnd ) )*X( Range( i+1, toEnd ) ) ) ;
|
||||
// theSum -= sum( LU( i, Range( i+1, toEnd ) )*B( Range( i+1, toEnd ) ) ) ;
|
||||
// Store a component of the solution vector :
|
||||
X( i ) = theSum/LU( i, i ) ;
|
||||
// B( i ) = theSum/LU( i, i ) ;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif
|
||||
147
cs440-acg/ext/eigen/bench/btl/libs/blitz/blitz_interface.hh
Normal file
147
cs440-acg/ext/eigen/bench/btl/libs/blitz/blitz_interface.hh
Normal file
@@ -0,0 +1,147 @@
|
||||
//=====================================================
|
||||
// File : blitz_interface.hh
|
||||
// Author : L. Plagne <laurent.plagne@edf.fr)>
|
||||
// Copyright (C) EDF R&D, lun sep 30 14:23:30 CEST 2002
|
||||
// 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 BLITZ_INTERFACE_HH
|
||||
#define BLITZ_INTERFACE_HH
|
||||
|
||||
#include <blitz/blitz.h>
|
||||
#include <blitz/array.h>
|
||||
#include <blitz/vector-et.h>
|
||||
#include <blitz/vecwhere.h>
|
||||
#include <blitz/matrix.h>
|
||||
#include <vector>
|
||||
|
||||
BZ_USING_NAMESPACE(blitz)
|
||||
|
||||
template<class real>
|
||||
class blitz_interface{
|
||||
|
||||
public :
|
||||
|
||||
typedef real real_type ;
|
||||
|
||||
typedef std::vector<real> stl_vector;
|
||||
typedef std::vector<stl_vector > stl_matrix;
|
||||
|
||||
typedef blitz::Array<real, 2> gene_matrix;
|
||||
typedef blitz::Array<real, 1> gene_vector;
|
||||
// typedef blitz::Matrix<real, blitz::ColumnMajor> gene_matrix;
|
||||
// typedef blitz::Vector<real> gene_vector;
|
||||
|
||||
static inline std::string name() { return "blitz"; }
|
||||
|
||||
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.resize(A_stl[0].size(),A_stl.size());
|
||||
for (int j=0; j<A_stl.size() ; j++){
|
||||
for (int i=0; i<A_stl[j].size() ; i++){
|
||||
A(i,j)=A_stl[j][i];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static inline void vector_from_stl(gene_vector & B, stl_vector & B_stl){
|
||||
B.resize(B_stl.size());
|
||||
for (int i=0; i<B_stl.size() ; i++){
|
||||
B(i)=B_stl[i];
|
||||
}
|
||||
}
|
||||
|
||||
static inline void vector_to_stl(gene_vector & B, stl_vector & B_stl){
|
||||
for (int i=0; i<B_stl.size() ; 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,j);
|
||||
}
|
||||
}
|
||||
|
||||
static inline void matrix_matrix_product(const gene_matrix & A, const gene_matrix & B, gene_matrix & X, int N)
|
||||
{
|
||||
firstIndex i;
|
||||
secondIndex j;
|
||||
thirdIndex k;
|
||||
X = sum(A(i,k) * B(k,j), k);
|
||||
}
|
||||
|
||||
static inline void ata_product(const gene_matrix & A, gene_matrix & X, int N)
|
||||
{
|
||||
firstIndex i;
|
||||
secondIndex j;
|
||||
thirdIndex k;
|
||||
X = sum(A(k,i) * A(k,j), k);
|
||||
}
|
||||
|
||||
static inline void aat_product(const gene_matrix & A, gene_matrix & X, int N)
|
||||
{
|
||||
firstIndex i;
|
||||
secondIndex j;
|
||||
thirdIndex k;
|
||||
X = sum(A(i,k) * A(j,k), k);
|
||||
}
|
||||
|
||||
static inline void matrix_vector_product(gene_matrix & A, gene_vector & B, gene_vector & X, int N)
|
||||
{
|
||||
firstIndex i;
|
||||
secondIndex j;
|
||||
X = sum(A(i,j)*B(j),j);
|
||||
}
|
||||
|
||||
static inline void atv_product(gene_matrix & A, gene_vector & B, gene_vector & X, int N)
|
||||
{
|
||||
firstIndex i;
|
||||
secondIndex j;
|
||||
X = sum(A(j,i) * B(j),j);
|
||||
}
|
||||
|
||||
static inline void axpy(const real coef, const gene_vector & X, gene_vector & Y, int N)
|
||||
{
|
||||
firstIndex i;
|
||||
Y = Y(i) + coef * X(i);
|
||||
//Y += coef * X;
|
||||
}
|
||||
|
||||
static inline void copy_matrix(const gene_matrix & source, gene_matrix & cible, int N){
|
||||
cible = source;
|
||||
//cible.template operator=<gene_matrix>(source);
|
||||
// for (int i=0;i<N;i++){
|
||||
// for (int j=0;j<N;j++){
|
||||
// cible(i,j)=source(i,j);
|
||||
// }
|
||||
// }
|
||||
}
|
||||
|
||||
static inline void copy_vector(const gene_vector & source, gene_vector & cible, int N){
|
||||
//cible.template operator=<gene_vector>(source);
|
||||
cible = source;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif
|
||||
51
cs440-acg/ext/eigen/bench/btl/libs/blitz/btl_blitz.cpp
Normal file
51
cs440-acg/ext/eigen/bench/btl/libs/blitz/btl_blitz.cpp
Normal file
@@ -0,0 +1,51 @@
|
||||
//=====================================================
|
||||
// File : main.cpp
|
||||
// Author : L. Plagne <laurent.plagne@edf.fr)>
|
||||
// Copyright (C) EDF R&D, lun sep 30 14:23:30 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 "blitz_interface.hh"
|
||||
#include "blitz_LU_solve_interface.hh"
|
||||
#include "bench.hh"
|
||||
#include "action_matrix_vector_product.hh"
|
||||
#include "action_matrix_matrix_product.hh"
|
||||
#include "action_axpy.hh"
|
||||
#include "action_lu_solve.hh"
|
||||
#include "action_ata_product.hh"
|
||||
#include "action_aat_product.hh"
|
||||
#include "action_atv_product.hh"
|
||||
|
||||
BTL_MAIN;
|
||||
|
||||
int main()
|
||||
{
|
||||
|
||||
bench<Action_matrix_vector_product<blitz_interface<REAL_TYPE> > >(MIN_MV,MAX_MV,NB_POINT);
|
||||
bench<Action_atv_product<blitz_interface<REAL_TYPE> > >(MIN_MV,MAX_MV,NB_POINT);
|
||||
|
||||
bench<Action_matrix_matrix_product<blitz_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
bench<Action_ata_product<blitz_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
bench<Action_aat_product<blitz_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
|
||||
bench<Action_axpy<blitz_interface<REAL_TYPE> > >(MIN_AXPY,MAX_AXPY,NB_POINT);
|
||||
|
||||
//bench<Action_lu_solve<blitz_LU_solve_interface<REAL_TYPE> > >(MIN_LU,MAX_LU,NB_POINT);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
38
cs440-acg/ext/eigen/bench/btl/libs/blitz/btl_tiny_blitz.cpp
Normal file
38
cs440-acg/ext/eigen/bench/btl/libs/blitz/btl_tiny_blitz.cpp
Normal file
@@ -0,0 +1,38 @@
|
||||
//=====================================================
|
||||
// File : main.cpp
|
||||
// Author : L. Plagne <laurent.plagne@edf.fr)>
|
||||
// Copyright (C) EDF R&D, lun sep 30 14:23:30 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 "tiny_blitz_interface.hh"
|
||||
#include "static/bench_static.hh"
|
||||
#include "action_matrix_vector_product.hh"
|
||||
#include "action_matrix_matrix_product.hh"
|
||||
#include "action_axpy.hh"
|
||||
|
||||
BTL_MAIN;
|
||||
|
||||
int main()
|
||||
{
|
||||
bench_static<Action_axpy,tiny_blitz_interface>();
|
||||
bench_static<Action_matrix_matrix_product,tiny_blitz_interface>();
|
||||
bench_static<Action_matrix_vector_product,tiny_blitz_interface>();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
106
cs440-acg/ext/eigen/bench/btl/libs/blitz/tiny_blitz_interface.hh
Normal file
106
cs440-acg/ext/eigen/bench/btl/libs/blitz/tiny_blitz_interface.hh
Normal file
@@ -0,0 +1,106 @@
|
||||
//=====================================================
|
||||
// File : tiny_blitz_interface.hh
|
||||
// Author : L. Plagne <laurent.plagne@edf.fr)>
|
||||
// Copyright (C) EDF R&D, lun sep 30 14:23:30 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 TINY_BLITZ_INTERFACE_HH
|
||||
#define TINY_BLITZ_INTERFACE_HH
|
||||
|
||||
#include "blitz/array.h"
|
||||
#include "blitz/tiny.h"
|
||||
#include "blitz/tinymat.h"
|
||||
#include "blitz/tinyvec.h"
|
||||
#include <blitz/tinyvec-et.h>
|
||||
|
||||
#include <vector>
|
||||
|
||||
BZ_USING_NAMESPACE(blitz)
|
||||
|
||||
template<class real, int SIZE>
|
||||
class tiny_blitz_interface
|
||||
{
|
||||
|
||||
public :
|
||||
|
||||
typedef real real_type ;
|
||||
|
||||
typedef std::vector<real> stl_vector;
|
||||
typedef std::vector<stl_vector > stl_matrix;
|
||||
|
||||
typedef TinyVector<real,SIZE> gene_vector;
|
||||
typedef TinyMatrix<real,SIZE,SIZE> gene_matrix;
|
||||
|
||||
static inline std::string name() { return "tiny_blitz"; }
|
||||
|
||||
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){
|
||||
for (int j=0; j<A_stl.size() ; j++)
|
||||
for (int i=0; i<A_stl[j].size() ; i++)
|
||||
A(i,j)=A_stl[j][i];
|
||||
}
|
||||
|
||||
static inline void vector_from_stl(gene_vector & B, stl_vector & B_stl){
|
||||
for (int i=0; i<B_stl.size() ; i++)
|
||||
B(i) = B_stl[i];
|
||||
}
|
||||
|
||||
static inline void vector_to_stl(gene_vector & B, stl_vector & B_stl){
|
||||
for (int i=0; i<B_stl.size() ; 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,j);
|
||||
}
|
||||
}
|
||||
|
||||
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,j) = source(i,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 matrix_matrix_product(const gene_matrix & A, const gene_matrix & B, gene_matrix & X, int N){
|
||||
X = product(A,B);
|
||||
}
|
||||
|
||||
static inline void matrix_vector_product(gene_matrix & A, gene_vector & B, gene_vector & X, int N){
|
||||
X = product(A,B);
|
||||
}
|
||||
|
||||
static inline void axpy(const real coef, const gene_vector & X, gene_vector & Y, int N){
|
||||
Y += coef * X;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
#endif
|
||||
19
cs440-acg/ext/eigen/bench/btl/libs/eigen2/CMakeLists.txt
Normal file
19
cs440-acg/ext/eigen/bench/btl/libs/eigen2/CMakeLists.txt
Normal file
@@ -0,0 +1,19 @@
|
||||
|
||||
find_package(Eigen2)
|
||||
|
||||
if(EIGEN2_FOUND)
|
||||
|
||||
include_directories(BEFORE ${EIGEN2_INCLUDE_DIR})
|
||||
btl_add_bench(btl_eigen2_linear main_linear.cpp)
|
||||
btl_add_bench(btl_eigen2_vecmat main_vecmat.cpp)
|
||||
btl_add_bench(btl_eigen2_matmat main_matmat.cpp)
|
||||
btl_add_bench(btl_eigen2_adv main_adv.cpp )
|
||||
|
||||
btl_add_target_property(btl_eigen2_linear COMPILE_FLAGS "-fno-exceptions -DBTL_PREFIX=eigen2")
|
||||
btl_add_target_property(btl_eigen2_vecmat COMPILE_FLAGS "-fno-exceptions -DBTL_PREFIX=eigen2")
|
||||
btl_add_target_property(btl_eigen2_matmat COMPILE_FLAGS "-fno-exceptions -DBTL_PREFIX=eigen2")
|
||||
btl_add_target_property(btl_eigen2_adv COMPILE_FLAGS "-fno-exceptions -DBTL_PREFIX=eigen2")
|
||||
|
||||
btl_add_bench(btl_tiny_eigen2 btl_tiny_eigen2.cpp OFF)
|
||||
|
||||
endif() # EIGEN2_FOUND
|
||||
@@ -0,0 +1,46 @@
|
||||
//=====================================================
|
||||
// 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.
|
||||
//
|
||||
#include "utilities.h"
|
||||
#include "eigen3_interface.hh"
|
||||
#include "static/bench_static.hh"
|
||||
#include "action_matrix_vector_product.hh"
|
||||
#include "action_matrix_matrix_product.hh"
|
||||
#include "action_axpy.hh"
|
||||
#include "action_lu_solve.hh"
|
||||
#include "action_ata_product.hh"
|
||||
#include "action_aat_product.hh"
|
||||
#include "action_atv_product.hh"
|
||||
#include "action_cholesky.hh"
|
||||
#include "action_trisolve.hh"
|
||||
|
||||
BTL_MAIN;
|
||||
|
||||
int main()
|
||||
{
|
||||
|
||||
bench_static<Action_axpy,eigen2_interface>();
|
||||
bench_static<Action_matrix_matrix_product,eigen2_interface>();
|
||||
bench_static<Action_matrix_vector_product,eigen2_interface>();
|
||||
bench_static<Action_atv_product,eigen2_interface>();
|
||||
bench_static<Action_cholesky,eigen2_interface>();
|
||||
bench_static<Action_trisolve,eigen2_interface>();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
168
cs440-acg/ext/eigen/bench/btl/libs/eigen2/eigen2_interface.hh
Normal file
168
cs440-acg/ext/eigen/bench/btl/libs/eigen2/eigen2_interface.hh
Normal file
@@ -0,0 +1,168 @@
|
||||
//=====================================================
|
||||
// Copyright (C) 2008 Gael Guennebaud <g.gael@free.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 EIGEN2_INTERFACE_HH
|
||||
#define EIGEN2_INTERFACE_HH
|
||||
// #include <cblas.h>
|
||||
#include <Eigen/Core>
|
||||
#include <Eigen/Cholesky>
|
||||
#include <Eigen/LU>
|
||||
#include <Eigen/QR>
|
||||
#include <vector>
|
||||
#include "btl.hh"
|
||||
|
||||
using namespace Eigen;
|
||||
|
||||
template<class real, int SIZE=Dynamic>
|
||||
class eigen2_interface
|
||||
{
|
||||
|
||||
public :
|
||||
|
||||
enum {IsFixedSize = (SIZE!=Dynamic)};
|
||||
|
||||
typedef real real_type;
|
||||
|
||||
typedef std::vector<real> stl_vector;
|
||||
typedef std::vector<stl_vector> stl_matrix;
|
||||
|
||||
typedef Eigen::Matrix<real,SIZE,SIZE> gene_matrix;
|
||||
typedef Eigen::Matrix<real,SIZE,1> gene_vector;
|
||||
|
||||
static inline std::string name( void )
|
||||
{
|
||||
#if defined(EIGEN_VECTORIZE_SSE)
|
||||
if (SIZE==Dynamic) return "eigen2"; else return "tiny_eigen2";
|
||||
#elif defined(EIGEN_VECTORIZE_ALTIVEC) || defined(EIGEN_VECTORIZE_VSX)
|
||||
if (SIZE==Dynamic) return "eigen2"; else return "tiny_eigen2";
|
||||
#else
|
||||
if (SIZE==Dynamic) return "eigen2_novec"; else return "tiny_eigen2_novec";
|
||||
#endif
|
||||
}
|
||||
|
||||
static void free_matrix(gene_matrix & A, int N) {}
|
||||
|
||||
static void free_vector(gene_vector & B) {}
|
||||
|
||||
static BTL_DONT_INLINE void matrix_from_stl(gene_matrix & A, stl_matrix & A_stl){
|
||||
A.resize(A_stl[0].size(), A_stl.size());
|
||||
|
||||
for (int j=0; j<A_stl.size() ; j++){
|
||||
for (int i=0; i<A_stl[j].size() ; i++){
|
||||
A.coeffRef(i,j) = A_stl[j][i];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static BTL_DONT_INLINE void vector_from_stl(gene_vector & B, stl_vector & B_stl){
|
||||
B.resize(B_stl.size(),1);
|
||||
|
||||
for (int i=0; i<B_stl.size() ; i++){
|
||||
B.coeffRef(i) = B_stl[i];
|
||||
}
|
||||
}
|
||||
|
||||
static BTL_DONT_INLINE void vector_to_stl(gene_vector & B, stl_vector & B_stl){
|
||||
for (int i=0; i<B_stl.size() ; i++){
|
||||
B_stl[i] = B.coeff(i);
|
||||
}
|
||||
}
|
||||
|
||||
static BTL_DONT_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.coeff(i,j);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static inline void matrix_matrix_product(const gene_matrix & A, const gene_matrix & B, gene_matrix & X, int N){
|
||||
X = (A*B).lazy();
|
||||
}
|
||||
|
||||
static inline void transposed_matrix_matrix_product(const gene_matrix & A, const gene_matrix & B, gene_matrix & X, int N){
|
||||
X = (A.transpose()*B.transpose()).lazy();
|
||||
}
|
||||
|
||||
static inline void ata_product(const gene_matrix & A, gene_matrix & X, int N){
|
||||
X = (A.transpose()*A).lazy();
|
||||
}
|
||||
|
||||
static inline void aat_product(const gene_matrix & A, gene_matrix & X, int N){
|
||||
X = (A*A.transpose()).lazy();
|
||||
}
|
||||
|
||||
static inline void matrix_vector_product(const gene_matrix & A, const gene_vector & B, gene_vector & X, int N){
|
||||
X = (A*B)/*.lazy()*/;
|
||||
}
|
||||
|
||||
static inline void atv_product(gene_matrix & A, gene_vector & B, gene_vector & X, int N){
|
||||
X = (A.transpose()*B)/*.lazy()*/;
|
||||
}
|
||||
|
||||
static inline void axpy(real coef, const gene_vector & X, gene_vector & Y, int N){
|
||||
Y += coef * X;
|
||||
}
|
||||
|
||||
static inline void axpby(real a, const gene_vector & X, real b, gene_vector & Y, int N){
|
||||
Y = a*X + b*Y;
|
||||
}
|
||||
|
||||
static inline void copy_matrix(const gene_matrix & source, gene_matrix & cible, int N){
|
||||
cible = source;
|
||||
}
|
||||
|
||||
static inline void copy_vector(const gene_vector & source, gene_vector & cible, int N){
|
||||
cible = source;
|
||||
}
|
||||
|
||||
static inline void trisolve_lower(const gene_matrix & L, const gene_vector& B, gene_vector& X, int N){
|
||||
X = L.template marked<LowerTriangular>().solveTriangular(B);
|
||||
}
|
||||
|
||||
static inline void trisolve_lower_matrix(const gene_matrix & L, const gene_matrix& B, gene_matrix& X, int N){
|
||||
X = L.template marked<LowerTriangular>().solveTriangular(B);
|
||||
}
|
||||
|
||||
static inline void cholesky(const gene_matrix & X, gene_matrix & C, int N){
|
||||
C = X.llt().matrixL();
|
||||
// C = X;
|
||||
// Cholesky<gene_matrix>::computeInPlace(C);
|
||||
// Cholesky<gene_matrix>::computeInPlaceBlock(C);
|
||||
}
|
||||
|
||||
static inline void lu_decomp(const gene_matrix & X, gene_matrix & C, int N){
|
||||
C = X.lu().matrixLU();
|
||||
// C = X.inverse();
|
||||
}
|
||||
|
||||
static inline void tridiagonalization(const gene_matrix & X, gene_matrix & C, int N){
|
||||
C = Tridiagonalization<gene_matrix>(X).packedMatrix();
|
||||
}
|
||||
|
||||
static inline void hessenberg(const gene_matrix & X, gene_matrix & C, int N){
|
||||
C = HessenbergDecomposition<gene_matrix>(X).packedMatrix();
|
||||
}
|
||||
|
||||
|
||||
|
||||
};
|
||||
|
||||
#endif
|
||||
44
cs440-acg/ext/eigen/bench/btl/libs/eigen2/main_adv.cpp
Normal file
44
cs440-acg/ext/eigen/bench/btl/libs/eigen2/main_adv.cpp
Normal file
@@ -0,0 +1,44 @@
|
||||
//=====================================================
|
||||
// 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.
|
||||
//
|
||||
#include "utilities.h"
|
||||
#include "eigen2_interface.hh"
|
||||
#include "bench.hh"
|
||||
#include "action_trisolve.hh"
|
||||
#include "action_trisolve_matrix.hh"
|
||||
#include "action_cholesky.hh"
|
||||
#include "action_hessenberg.hh"
|
||||
#include "action_lu_decomp.hh"
|
||||
// #include "action_partial_lu.hh"
|
||||
|
||||
BTL_MAIN;
|
||||
|
||||
int main()
|
||||
{
|
||||
bench<Action_trisolve<eigen2_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
bench<Action_trisolve_matrix<eigen2_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
bench<Action_cholesky<eigen2_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
bench<Action_lu_decomp<eigen2_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
// bench<Action_partial_lu<eigen2_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
|
||||
bench<Action_hessenberg<eigen2_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
bench<Action_tridiagonalization<eigen2_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
34
cs440-acg/ext/eigen/bench/btl/libs/eigen2/main_linear.cpp
Normal file
34
cs440-acg/ext/eigen/bench/btl/libs/eigen2/main_linear.cpp
Normal file
@@ -0,0 +1,34 @@
|
||||
//=====================================================
|
||||
// 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.
|
||||
//
|
||||
#include "utilities.h"
|
||||
#include "eigen2_interface.hh"
|
||||
#include "bench.hh"
|
||||
#include "basic_actions.hh"
|
||||
|
||||
BTL_MAIN;
|
||||
|
||||
int main()
|
||||
{
|
||||
|
||||
bench<Action_axpy<eigen2_interface<REAL_TYPE> > >(MIN_AXPY,MAX_AXPY,NB_POINT);
|
||||
bench<Action_axpby<eigen2_interface<REAL_TYPE> > >(MIN_AXPY,MAX_AXPY,NB_POINT);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
35
cs440-acg/ext/eigen/bench/btl/libs/eigen2/main_matmat.cpp
Normal file
35
cs440-acg/ext/eigen/bench/btl/libs/eigen2/main_matmat.cpp
Normal file
@@ -0,0 +1,35 @@
|
||||
//=====================================================
|
||||
// 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.
|
||||
//
|
||||
#include "utilities.h"
|
||||
#include "eigen2_interface.hh"
|
||||
#include "bench.hh"
|
||||
#include "basic_actions.hh"
|
||||
|
||||
BTL_MAIN;
|
||||
|
||||
int main()
|
||||
{
|
||||
bench<Action_matrix_matrix_product<eigen2_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
// bench<Action_ata_product<eigen2_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
bench<Action_aat_product<eigen2_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
// bench<Action_trmm<eigen2_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
36
cs440-acg/ext/eigen/bench/btl/libs/eigen2/main_vecmat.cpp
Normal file
36
cs440-acg/ext/eigen/bench/btl/libs/eigen2/main_vecmat.cpp
Normal file
@@ -0,0 +1,36 @@
|
||||
//=====================================================
|
||||
// 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.
|
||||
//
|
||||
#include "utilities.h"
|
||||
#include "eigen2_interface.hh"
|
||||
#include "bench.hh"
|
||||
#include "basic_actions.hh"
|
||||
|
||||
BTL_MAIN;
|
||||
|
||||
int main()
|
||||
{
|
||||
bench<Action_matrix_vector_product<eigen2_interface<REAL_TYPE> > >(MIN_MV,MAX_MV,NB_POINT);
|
||||
bench<Action_atv_product<eigen2_interface<REAL_TYPE> > >(MIN_MV,MAX_MV,NB_POINT);
|
||||
// bench<Action_symv<eigen2_interface<REAL_TYPE> > >(MIN_MV,MAX_MV,NB_POINT);
|
||||
// bench<Action_syr2<eigen2_interface<REAL_TYPE> > >(MIN_MV,MAX_MV,NB_POINT);
|
||||
// bench<Action_ger<eigen2_interface<REAL_TYPE> > >(MIN_MV,MAX_MV,NB_POINT);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
65
cs440-acg/ext/eigen/bench/btl/libs/eigen3/CMakeLists.txt
Normal file
65
cs440-acg/ext/eigen/bench/btl/libs/eigen3/CMakeLists.txt
Normal file
@@ -0,0 +1,65 @@
|
||||
|
||||
|
||||
if((NOT EIGEN3_INCLUDE_DIR) AND Eigen_SOURCE_DIR)
|
||||
# unless EIGEN3_INCLUDE_DIR is defined, let's use current Eigen version
|
||||
set(EIGEN3_INCLUDE_DIR ${Eigen_SOURCE_DIR})
|
||||
set(EIGEN3_FOUND TRUE)
|
||||
else()
|
||||
find_package(Eigen3)
|
||||
endif()
|
||||
|
||||
if (EIGEN3_FOUND)
|
||||
|
||||
include_directories(${EIGEN3_INCLUDE_DIR})
|
||||
btl_add_bench(btl_eigen3_linear main_linear.cpp)
|
||||
btl_add_bench(btl_eigen3_vecmat main_vecmat.cpp)
|
||||
btl_add_bench(btl_eigen3_matmat main_matmat.cpp)
|
||||
btl_add_bench(btl_eigen3_adv main_adv.cpp )
|
||||
|
||||
btl_add_target_property(btl_eigen3_linear COMPILE_FLAGS "-fno-exceptions -DBTL_PREFIX=eigen3")
|
||||
btl_add_target_property(btl_eigen3_vecmat COMPILE_FLAGS "-fno-exceptions -DBTL_PREFIX=eigen3")
|
||||
btl_add_target_property(btl_eigen3_matmat COMPILE_FLAGS "-fno-exceptions -DBTL_PREFIX=eigen3")
|
||||
btl_add_target_property(btl_eigen3_adv COMPILE_FLAGS "-fno-exceptions -DBTL_PREFIX=eigen3")
|
||||
|
||||
option(BTL_BENCH_NOGCCVEC "also bench Eigen explicit vec without GCC's auto vec" OFF)
|
||||
if(CMAKE_COMPILER_IS_GNUCXX AND BTL_BENCH_NOGCCVEC)
|
||||
btl_add_bench(btl_eigen3_nogccvec_linear main_linear.cpp)
|
||||
btl_add_bench(btl_eigen3_nogccvec_vecmat main_vecmat.cpp)
|
||||
btl_add_bench(btl_eigen3_nogccvec_matmat main_matmat.cpp)
|
||||
btl_add_bench(btl_eigen3_nogccvec_adv main_adv.cpp )
|
||||
|
||||
btl_add_target_property(btl_eigen3_nogccvec_linear COMPILE_FLAGS "-fno-exceptions -fno-tree-vectorize -DBTL_PREFIX=eigen3_nogccvec")
|
||||
btl_add_target_property(btl_eigen3_nogccvec_vecmat COMPILE_FLAGS "-fno-exceptions -fno-tree-vectorize -DBTL_PREFIX=eigen3_nogccvec")
|
||||
btl_add_target_property(btl_eigen3_nogccvec_matmat COMPILE_FLAGS "-fno-exceptions -fno-tree-vectorize -DBTL_PREFIX=eigen3_nogccvec")
|
||||
btl_add_target_property(btl_eigen3_nogccvec_adv COMPILE_FLAGS "-fno-exceptions -fno-tree-vectorize -DBTL_PREFIX=eigen3_nogccvec")
|
||||
endif()
|
||||
|
||||
|
||||
if(NOT BTL_NOVEC)
|
||||
btl_add_bench(btl_eigen3_novec_linear main_linear.cpp OFF)
|
||||
btl_add_bench(btl_eigen3_novec_vecmat main_vecmat.cpp OFF)
|
||||
btl_add_bench(btl_eigen3_novec_matmat main_matmat.cpp OFF)
|
||||
btl_add_bench(btl_eigen3_novec_adv main_adv.cpp OFF)
|
||||
btl_add_target_property(btl_eigen3_novec_linear COMPILE_FLAGS "-fno-exceptions -DEIGEN_DONT_VECTORIZE -DBTL_PREFIX=eigen3_novec")
|
||||
btl_add_target_property(btl_eigen3_novec_vecmat COMPILE_FLAGS "-fno-exceptions -DEIGEN_DONT_VECTORIZE -DBTL_PREFIX=eigen3_novec")
|
||||
btl_add_target_property(btl_eigen3_novec_matmat COMPILE_FLAGS "-fno-exceptions -DEIGEN_DONT_VECTORIZE -DBTL_PREFIX=eigen3_novec")
|
||||
btl_add_target_property(btl_eigen3_novec_adv COMPILE_FLAGS "-fno-exceptions -DEIGEN_DONT_VECTORIZE -DBTL_PREFIX=eigen3_novec")
|
||||
|
||||
# if(BUILD_btl_eigen3_adv)
|
||||
# target_link_libraries(btl_eigen3_adv ${MKL_LIBRARIES})
|
||||
# endif(BUILD_btl_eigen3_adv)
|
||||
|
||||
endif(NOT BTL_NOVEC)
|
||||
|
||||
btl_add_bench(btl_tiny_eigen3 btl_tiny_eigen3.cpp OFF)
|
||||
|
||||
if(NOT BTL_NOVEC)
|
||||
btl_add_bench(btl_tiny_eigen3_novec btl_tiny_eigen3.cpp OFF)
|
||||
btl_add_target_property(btl_tiny_eigen3_novec COMPILE_FLAGS "-DBTL_PREFIX=eigen3_tiny")
|
||||
|
||||
if(BUILD_btl_tiny_eigen3_novec)
|
||||
btl_add_target_property(btl_tiny_eigen3_novec COMPILE_FLAGS "-DEIGEN_DONT_VECTORIZE -DBTL_PREFIX=eigen3_tiny_novec")
|
||||
endif(BUILD_btl_tiny_eigen3_novec)
|
||||
endif(NOT BTL_NOVEC)
|
||||
|
||||
endif (EIGEN3_FOUND)
|
||||
@@ -0,0 +1,46 @@
|
||||
//=====================================================
|
||||
// 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.
|
||||
//
|
||||
#include "utilities.h"
|
||||
#include "eigen3_interface.hh"
|
||||
#include "static/bench_static.hh"
|
||||
#include "action_matrix_vector_product.hh"
|
||||
#include "action_matrix_matrix_product.hh"
|
||||
#include "action_axpy.hh"
|
||||
#include "action_lu_solve.hh"
|
||||
#include "action_ata_product.hh"
|
||||
#include "action_aat_product.hh"
|
||||
#include "action_atv_product.hh"
|
||||
#include "action_cholesky.hh"
|
||||
#include "action_trisolve.hh"
|
||||
|
||||
BTL_MAIN;
|
||||
|
||||
int main()
|
||||
{
|
||||
|
||||
bench_static<Action_axpy,eigen2_interface>();
|
||||
bench_static<Action_matrix_matrix_product,eigen2_interface>();
|
||||
bench_static<Action_matrix_vector_product,eigen2_interface>();
|
||||
bench_static<Action_atv_product,eigen2_interface>();
|
||||
bench_static<Action_cholesky,eigen2_interface>();
|
||||
bench_static<Action_trisolve,eigen2_interface>();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
240
cs440-acg/ext/eigen/bench/btl/libs/eigen3/eigen3_interface.hh
Normal file
240
cs440-acg/ext/eigen/bench/btl/libs/eigen3/eigen3_interface.hh
Normal file
@@ -0,0 +1,240 @@
|
||||
//=====================================================
|
||||
// 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 EIGEN3_INTERFACE_HH
|
||||
#define EIGEN3_INTERFACE_HH
|
||||
|
||||
#include <Eigen/Eigen>
|
||||
#include <vector>
|
||||
#include "btl.hh"
|
||||
|
||||
using namespace Eigen;
|
||||
|
||||
template<class real, int SIZE=Dynamic>
|
||||
class eigen3_interface
|
||||
{
|
||||
|
||||
public :
|
||||
|
||||
enum {IsFixedSize = (SIZE!=Dynamic)};
|
||||
|
||||
typedef real real_type;
|
||||
|
||||
typedef std::vector<real> stl_vector;
|
||||
typedef std::vector<stl_vector> stl_matrix;
|
||||
|
||||
typedef Eigen::Matrix<real,SIZE,SIZE> gene_matrix;
|
||||
typedef Eigen::Matrix<real,SIZE,1> gene_vector;
|
||||
|
||||
static inline std::string name( void )
|
||||
{
|
||||
return EIGEN_MAKESTRING(BTL_PREFIX);
|
||||
}
|
||||
|
||||
static void free_matrix(gene_matrix & /*A*/, int /*N*/) {}
|
||||
|
||||
static void free_vector(gene_vector & /*B*/) {}
|
||||
|
||||
static BTL_DONT_INLINE void matrix_from_stl(gene_matrix & A, stl_matrix & A_stl){
|
||||
A.resize(A_stl[0].size(), A_stl.size());
|
||||
|
||||
for (unsigned int j=0; j<A_stl.size() ; j++){
|
||||
for (unsigned int i=0; i<A_stl[j].size() ; i++){
|
||||
A.coeffRef(i,j) = A_stl[j][i];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static BTL_DONT_INLINE void vector_from_stl(gene_vector & B, stl_vector & B_stl){
|
||||
B.resize(B_stl.size(),1);
|
||||
|
||||
for (unsigned int i=0; i<B_stl.size() ; i++){
|
||||
B.coeffRef(i) = B_stl[i];
|
||||
}
|
||||
}
|
||||
|
||||
static BTL_DONT_INLINE void vector_to_stl(gene_vector & B, stl_vector & B_stl){
|
||||
for (unsigned int i=0; i<B_stl.size() ; i++){
|
||||
B_stl[i] = B.coeff(i);
|
||||
}
|
||||
}
|
||||
|
||||
static BTL_DONT_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.coeff(i,j);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static inline void matrix_matrix_product(const gene_matrix & A, const gene_matrix & B, gene_matrix & X, int /*N*/){
|
||||
X.noalias() = A*B;
|
||||
}
|
||||
|
||||
static inline void transposed_matrix_matrix_product(const gene_matrix & A, const gene_matrix & B, gene_matrix & X, int /*N*/){
|
||||
X.noalias() = A.transpose()*B.transpose();
|
||||
}
|
||||
|
||||
// static inline void ata_product(const gene_matrix & A, gene_matrix & X, int /*N*/){
|
||||
// X.noalias() = A.transpose()*A;
|
||||
// }
|
||||
|
||||
static inline void aat_product(const gene_matrix & A, gene_matrix & X, int /*N*/){
|
||||
X.template triangularView<Lower>().setZero();
|
||||
X.template selfadjointView<Lower>().rankUpdate(A);
|
||||
}
|
||||
|
||||
static inline void matrix_vector_product(const gene_matrix & A, const gene_vector & B, gene_vector & X, int /*N*/){
|
||||
X.noalias() = A*B;
|
||||
}
|
||||
|
||||
static inline void symv(const gene_matrix & A, const gene_vector & B, gene_vector & X, int /*N*/){
|
||||
X.noalias() = (A.template selfadjointView<Lower>() * B);
|
||||
// internal::product_selfadjoint_vector<real,0,LowerTriangularBit,false,false>(N,A.data(),N, B.data(), 1, X.data(), 1);
|
||||
}
|
||||
|
||||
template<typename Dest, typename Src> static void triassign(Dest& dst, const Src& src)
|
||||
{
|
||||
typedef typename Dest::Scalar Scalar;
|
||||
typedef typename internal::packet_traits<Scalar>::type Packet;
|
||||
const int PacketSize = sizeof(Packet)/sizeof(Scalar);
|
||||
int size = dst.cols();
|
||||
for(int j=0; j<size; j+=1)
|
||||
{
|
||||
// const int alignedEnd = alignedStart + ((innerSize-alignedStart) & ~packetAlignedMask);
|
||||
Scalar* A0 = dst.data() + j*dst.stride();
|
||||
int starti = j;
|
||||
int alignedEnd = starti;
|
||||
int alignedStart = (starti) + internal::first_aligned(&A0[starti], size-starti);
|
||||
alignedEnd = alignedStart + ((size-alignedStart)/(2*PacketSize))*(PacketSize*2);
|
||||
|
||||
// do the non-vectorizable part of the assignment
|
||||
for (int index = starti; index<alignedStart ; ++index)
|
||||
{
|
||||
if(Dest::Flags&RowMajorBit)
|
||||
dst.copyCoeff(j, index, src);
|
||||
else
|
||||
dst.copyCoeff(index, j, src);
|
||||
}
|
||||
|
||||
// do the vectorizable part of the assignment
|
||||
for (int index = alignedStart; index<alignedEnd; index+=PacketSize)
|
||||
{
|
||||
if(Dest::Flags&RowMajorBit)
|
||||
dst.template copyPacket<Src, Aligned, Unaligned>(j, index, src);
|
||||
else
|
||||
dst.template copyPacket<Src, Aligned, Unaligned>(index, j, src);
|
||||
}
|
||||
|
||||
// do the non-vectorizable part of the assignment
|
||||
for (int index = alignedEnd; index<size; ++index)
|
||||
{
|
||||
if(Dest::Flags&RowMajorBit)
|
||||
dst.copyCoeff(j, index, src);
|
||||
else
|
||||
dst.copyCoeff(index, j, src);
|
||||
}
|
||||
//dst.col(j).tail(N-j) = src.col(j).tail(N-j);
|
||||
}
|
||||
}
|
||||
|
||||
static EIGEN_DONT_INLINE void syr2(gene_matrix & A, gene_vector & X, gene_vector & Y, int N){
|
||||
// internal::product_selfadjoint_rank2_update<real,0,LowerTriangularBit>(N,A.data(),N, X.data(), 1, Y.data(), 1, -1);
|
||||
for(int j=0; j<N; ++j)
|
||||
A.col(j).tail(N-j) += X[j] * Y.tail(N-j) + Y[j] * X.tail(N-j);
|
||||
}
|
||||
|
||||
static EIGEN_DONT_INLINE void ger(gene_matrix & A, gene_vector & X, gene_vector & Y, int N){
|
||||
for(int j=0; j<N; ++j)
|
||||
A.col(j) += X * Y[j];
|
||||
}
|
||||
|
||||
static EIGEN_DONT_INLINE void rot(gene_vector & A, gene_vector & B, real c, real s, int /*N*/){
|
||||
internal::apply_rotation_in_the_plane(A, B, JacobiRotation<real>(c,s));
|
||||
}
|
||||
|
||||
static inline void atv_product(gene_matrix & A, gene_vector & B, gene_vector & X, int /*N*/){
|
||||
X.noalias() = (A.transpose()*B);
|
||||
}
|
||||
|
||||
static inline void axpy(real coef, const gene_vector & X, gene_vector & Y, int /*N*/){
|
||||
Y += coef * X;
|
||||
}
|
||||
|
||||
static inline void axpby(real a, const gene_vector & X, real b, gene_vector & Y, int /*N*/){
|
||||
Y = a*X + b*Y;
|
||||
}
|
||||
|
||||
static EIGEN_DONT_INLINE void copy_matrix(const gene_matrix & source, gene_matrix & cible, int /*N*/){
|
||||
cible = source;
|
||||
}
|
||||
|
||||
static EIGEN_DONT_INLINE void copy_vector(const gene_vector & source, gene_vector & cible, int /*N*/){
|
||||
cible = source;
|
||||
}
|
||||
|
||||
static inline void trisolve_lower(const gene_matrix & L, const gene_vector& B, gene_vector& X, int /*N*/){
|
||||
X = L.template triangularView<Lower>().solve(B);
|
||||
}
|
||||
|
||||
static inline void trisolve_lower_matrix(const gene_matrix & L, const gene_matrix& B, gene_matrix& X, int /*N*/){
|
||||
X = L.template triangularView<Upper>().solve(B);
|
||||
}
|
||||
|
||||
static inline void trmm(const gene_matrix & L, const gene_matrix& B, gene_matrix& X, int /*N*/){
|
||||
X.noalias() = L.template triangularView<Lower>() * B;
|
||||
}
|
||||
|
||||
static inline void cholesky(const gene_matrix & X, gene_matrix & C, int /*N*/){
|
||||
C = X;
|
||||
internal::llt_inplace<real,Lower>::blocked(C);
|
||||
//C = X.llt().matrixL();
|
||||
// C = X;
|
||||
// Cholesky<gene_matrix>::computeInPlace(C);
|
||||
// Cholesky<gene_matrix>::computeInPlaceBlock(C);
|
||||
}
|
||||
|
||||
static inline void lu_decomp(const gene_matrix & X, gene_matrix & C, int /*N*/){
|
||||
C = X.fullPivLu().matrixLU();
|
||||
}
|
||||
|
||||
static inline void partial_lu_decomp(const gene_matrix & X, gene_matrix & C, int N){
|
||||
Matrix<DenseIndex,1,Dynamic> piv(N);
|
||||
DenseIndex nb;
|
||||
C = X;
|
||||
internal::partial_lu_inplace(C,piv,nb);
|
||||
// C = X.partialPivLu().matrixLU();
|
||||
}
|
||||
|
||||
static inline void tridiagonalization(const gene_matrix & X, gene_matrix & C, int N){
|
||||
typename Tridiagonalization<gene_matrix>::CoeffVectorType aux(N-1);
|
||||
C = X;
|
||||
internal::tridiagonalization_inplace(C, aux);
|
||||
}
|
||||
|
||||
static inline void hessenberg(const gene_matrix & X, gene_matrix & C, int /*N*/){
|
||||
C = HessenbergDecomposition<gene_matrix>(X).packedMatrix();
|
||||
}
|
||||
|
||||
|
||||
|
||||
};
|
||||
|
||||
#endif
|
||||
44
cs440-acg/ext/eigen/bench/btl/libs/eigen3/main_adv.cpp
Normal file
44
cs440-acg/ext/eigen/bench/btl/libs/eigen3/main_adv.cpp
Normal file
@@ -0,0 +1,44 @@
|
||||
//=====================================================
|
||||
// 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.
|
||||
//
|
||||
#include "utilities.h"
|
||||
#include "eigen3_interface.hh"
|
||||
#include "bench.hh"
|
||||
#include "action_trisolve.hh"
|
||||
#include "action_trisolve_matrix.hh"
|
||||
#include "action_cholesky.hh"
|
||||
#include "action_hessenberg.hh"
|
||||
#include "action_lu_decomp.hh"
|
||||
#include "action_partial_lu.hh"
|
||||
|
||||
BTL_MAIN;
|
||||
|
||||
int main()
|
||||
{
|
||||
bench<Action_trisolve<eigen3_interface<REAL_TYPE> > >(MIN_LU,MAX_LU,NB_POINT);
|
||||
bench<Action_trisolve_matrix<eigen3_interface<REAL_TYPE> > >(MIN_LU,MAX_LU,NB_POINT);
|
||||
bench<Action_cholesky<eigen3_interface<REAL_TYPE> > >(MIN_LU,MAX_LU,NB_POINT);
|
||||
// bench<Action_lu_decomp<eigen3_interface<REAL_TYPE> > >(MIN_LU,MAX_LU,NB_POINT);
|
||||
bench<Action_partial_lu<eigen3_interface<REAL_TYPE> > >(MIN_LU,MAX_LU,NB_POINT);
|
||||
|
||||
// bench<Action_hessenberg<eigen3_interface<REAL_TYPE> > >(MIN_LU,MAX_LU,NB_POINT);
|
||||
bench<Action_tridiagonalization<eigen3_interface<REAL_TYPE> > >(MIN_LU,MAX_LU,NB_POINT);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
35
cs440-acg/ext/eigen/bench/btl/libs/eigen3/main_linear.cpp
Normal file
35
cs440-acg/ext/eigen/bench/btl/libs/eigen3/main_linear.cpp
Normal file
@@ -0,0 +1,35 @@
|
||||
//=====================================================
|
||||
// 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.
|
||||
//
|
||||
#include "utilities.h"
|
||||
#include "eigen3_interface.hh"
|
||||
#include "bench.hh"
|
||||
#include "basic_actions.hh"
|
||||
|
||||
BTL_MAIN;
|
||||
|
||||
int main()
|
||||
{
|
||||
|
||||
bench<Action_axpy<eigen3_interface<REAL_TYPE> > >(MIN_AXPY,MAX_AXPY,NB_POINT);
|
||||
bench<Action_axpby<eigen3_interface<REAL_TYPE> > >(MIN_AXPY,MAX_AXPY,NB_POINT);
|
||||
bench<Action_rot<eigen3_interface<REAL_TYPE> > >(MIN_AXPY,MAX_AXPY,NB_POINT);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
35
cs440-acg/ext/eigen/bench/btl/libs/eigen3/main_matmat.cpp
Normal file
35
cs440-acg/ext/eigen/bench/btl/libs/eigen3/main_matmat.cpp
Normal file
@@ -0,0 +1,35 @@
|
||||
//=====================================================
|
||||
// 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.
|
||||
//
|
||||
#include "utilities.h"
|
||||
#include "eigen3_interface.hh"
|
||||
#include "bench.hh"
|
||||
#include "basic_actions.hh"
|
||||
|
||||
BTL_MAIN;
|
||||
|
||||
int main()
|
||||
{
|
||||
bench<Action_matrix_matrix_product<eigen3_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
// bench<Action_ata_product<eigen3_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
bench<Action_aat_product<eigen3_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
bench<Action_trmm<eigen3_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
36
cs440-acg/ext/eigen/bench/btl/libs/eigen3/main_vecmat.cpp
Normal file
36
cs440-acg/ext/eigen/bench/btl/libs/eigen3/main_vecmat.cpp
Normal file
@@ -0,0 +1,36 @@
|
||||
//=====================================================
|
||||
// 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.
|
||||
//
|
||||
#include "utilities.h"
|
||||
#include "eigen3_interface.hh"
|
||||
#include "bench.hh"
|
||||
#include "basic_actions.hh"
|
||||
|
||||
BTL_MAIN;
|
||||
|
||||
int main()
|
||||
{
|
||||
bench<Action_matrix_vector_product<eigen3_interface<REAL_TYPE> > >(MIN_MV,MAX_MV,NB_POINT);
|
||||
bench<Action_atv_product<eigen3_interface<REAL_TYPE> > >(MIN_MV,MAX_MV,NB_POINT);
|
||||
bench<Action_symv<eigen3_interface<REAL_TYPE> > >(MIN_MV,MAX_MV,NB_POINT);
|
||||
bench<Action_syr2<eigen3_interface<REAL_TYPE> > >(MIN_MV,MAX_MV,NB_POINT);
|
||||
bench<Action_ger<eigen3_interface<REAL_TYPE> > >(MIN_MV,MAX_MV,NB_POINT);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
6
cs440-acg/ext/eigen/bench/btl/libs/gmm/CMakeLists.txt
Normal file
6
cs440-acg/ext/eigen/bench/btl/libs/gmm/CMakeLists.txt
Normal file
@@ -0,0 +1,6 @@
|
||||
|
||||
find_package(GMM)
|
||||
if (GMM_FOUND)
|
||||
include_directories(${GMM_INCLUDES})
|
||||
btl_add_bench(btl_gmm main.cpp)
|
||||
endif (GMM_FOUND)
|
||||
192
cs440-acg/ext/eigen/bench/btl/libs/gmm/gmm_LU_solve_interface.hh
Normal file
192
cs440-acg/ext/eigen/bench/btl/libs/gmm/gmm_LU_solve_interface.hh
Normal file
@@ -0,0 +1,192 @@
|
||||
//=====================================================
|
||||
// File : blitz_LU_solve_interface.hh
|
||||
// Author : L. Plagne <laurent.plagne@edf.fr)>
|
||||
// Copyright (C) EDF R&D, lun sep 30 14:23:31 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 BLITZ_LU_SOLVE_INTERFACE_HH
|
||||
#define BLITZ_LU_SOLVE_INTERFACE_HH
|
||||
|
||||
#include "blitz/array.h"
|
||||
#include <vector>
|
||||
|
||||
BZ_USING_NAMESPACE(blitz)
|
||||
|
||||
template<class real>
|
||||
class blitz_LU_solve_interface : public blitz_interface<real>
|
||||
{
|
||||
|
||||
public :
|
||||
|
||||
typedef typename blitz_interface<real>::gene_matrix gene_matrix;
|
||||
typedef typename blitz_interface<real>::gene_vector gene_vector;
|
||||
|
||||
typedef blitz::Array<int,1> Pivot_Vector;
|
||||
|
||||
inline static void new_Pivot_Vector(Pivot_Vector & pivot,int N)
|
||||
{
|
||||
|
||||
pivot.resize(N);
|
||||
|
||||
}
|
||||
|
||||
inline static void free_Pivot_Vector(Pivot_Vector & pivot)
|
||||
{
|
||||
|
||||
return;
|
||||
|
||||
}
|
||||
|
||||
|
||||
static inline real matrix_vector_product_sliced(const gene_matrix & A, gene_vector B, int row, int col_start, int col_end)
|
||||
{
|
||||
|
||||
real somme=0.;
|
||||
|
||||
for (int j=col_start ; j<col_end+1 ; j++){
|
||||
|
||||
somme+=A(row,j)*B(j);
|
||||
|
||||
}
|
||||
|
||||
return somme;
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
static inline real matrix_matrix_product_sliced(gene_matrix & A, int row, int col_start, int col_end, gene_matrix & B, int row_shift, int col )
|
||||
{
|
||||
|
||||
real somme=0.;
|
||||
|
||||
for (int j=col_start ; j<col_end+1 ; j++){
|
||||
|
||||
somme+=A(row,j)*B(j+row_shift,col);
|
||||
|
||||
}
|
||||
|
||||
return somme;
|
||||
|
||||
}
|
||||
|
||||
inline static void LU_factor(gene_matrix & LU, Pivot_Vector & pivot, int N)
|
||||
{
|
||||
|
||||
ASSERT( LU.rows()==LU.cols() ) ;
|
||||
int index_max = 0 ;
|
||||
real big = 0. ;
|
||||
real theSum = 0. ;
|
||||
real dum = 0. ;
|
||||
// Get the implicit scaling information :
|
||||
gene_vector ImplicitScaling( N ) ;
|
||||
for( int i=0; i<N; i++ ) {
|
||||
big = 0. ;
|
||||
for( int j=0; j<N; j++ ) {
|
||||
if( abs( LU( i, j ) )>=big ) big = abs( LU( i, j ) ) ;
|
||||
}
|
||||
if( big==0. ) {
|
||||
INFOS( "blitz_LU_factor::Singular matrix" ) ;
|
||||
exit( 0 ) ;
|
||||
}
|
||||
ImplicitScaling( i ) = 1./big ;
|
||||
}
|
||||
// Loop over columns of Crout's method :
|
||||
for( int j=0; j<N; j++ ) {
|
||||
for( int i=0; i<j; i++ ) {
|
||||
theSum = LU( i, j ) ;
|
||||
theSum -= matrix_matrix_product_sliced(LU, i, 0, i-1, LU, 0, j) ;
|
||||
// theSum -= sum( LU( i, Range( fromStart, i-1 ) )*LU( Range( fromStart, i-1 ), j ) ) ;
|
||||
LU( i, j ) = theSum ;
|
||||
}
|
||||
|
||||
// Search for the largest pivot element :
|
||||
big = 0. ;
|
||||
for( int i=j; i<N; i++ ) {
|
||||
theSum = LU( i, j ) ;
|
||||
theSum -= matrix_matrix_product_sliced(LU, i, 0, j-1, LU, 0, j) ;
|
||||
// theSum -= sum( LU( i, Range( fromStart, j-1 ) )*LU( Range( fromStart, j-1 ), j ) ) ;
|
||||
LU( i, j ) = theSum ;
|
||||
if( (ImplicitScaling( i )*abs( theSum ))>=big ) {
|
||||
dum = ImplicitScaling( i )*abs( theSum ) ;
|
||||
big = dum ;
|
||||
index_max = i ;
|
||||
}
|
||||
}
|
||||
// Interchanging rows and the scale factor :
|
||||
if( j!=index_max ) {
|
||||
for( int k=0; k<N; k++ ) {
|
||||
dum = LU( index_max, k ) ;
|
||||
LU( index_max, k ) = LU( j, k ) ;
|
||||
LU( j, k ) = dum ;
|
||||
}
|
||||
ImplicitScaling( index_max ) = ImplicitScaling( j ) ;
|
||||
}
|
||||
pivot( j ) = index_max ;
|
||||
if ( LU( j, j )==0. ) LU( j, j ) = 1.e-20 ;
|
||||
// Divide by the pivot element :
|
||||
if( j<N ) {
|
||||
dum = 1./LU( j, j ) ;
|
||||
for( int i=j+1; i<N; i++ ) LU( i, j ) *= dum ;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
inline static void LU_solve(const gene_matrix & LU, const Pivot_Vector pivot, gene_vector &B, gene_vector X, int N)
|
||||
{
|
||||
|
||||
// Pour conserver le meme header, on travaille sur X, copie du second-membre B
|
||||
X = B.copy() ;
|
||||
ASSERT( LU.rows()==LU.cols() ) ;
|
||||
firstIndex indI ;
|
||||
// Forward substitution :
|
||||
int ii = 0 ;
|
||||
real theSum = 0. ;
|
||||
for( int i=0; i<N; i++ ) {
|
||||
int ip = pivot( i ) ;
|
||||
theSum = X( ip ) ;
|
||||
// theSum = B( ip ) ;
|
||||
X( ip ) = X( i ) ;
|
||||
// B( ip ) = B( i ) ;
|
||||
if( ii ) {
|
||||
theSum -= matrix_vector_product_sliced(LU, X, i, ii-1, i-1) ;
|
||||
// theSum -= sum( LU( i, Range( ii-1, i-1 ) )*X( Range( ii-1, i-1 ) ) ) ;
|
||||
// theSum -= sum( LU( i, Range( ii-1, i-1 ) )*B( Range( ii-1, i-1 ) ) ) ;
|
||||
} else if( theSum ) {
|
||||
ii = i+1 ;
|
||||
}
|
||||
X( i ) = theSum ;
|
||||
// B( i ) = theSum ;
|
||||
}
|
||||
// Backsubstitution :
|
||||
for( int i=N-1; i>=0; i-- ) {
|
||||
theSum = X( i ) ;
|
||||
// theSum = B( i ) ;
|
||||
theSum -= matrix_vector_product_sliced(LU, X, i, i+1, N) ;
|
||||
// theSum -= sum( LU( i, Range( i+1, toEnd ) )*X( Range( i+1, toEnd ) ) ) ;
|
||||
// theSum -= sum( LU( i, Range( i+1, toEnd ) )*B( Range( i+1, toEnd ) ) ) ;
|
||||
// Store a component of the solution vector :
|
||||
X( i ) = theSum/LU( i, i ) ;
|
||||
// B( i ) = theSum/LU( i, i ) ;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif
|
||||
144
cs440-acg/ext/eigen/bench/btl/libs/gmm/gmm_interface.hh
Normal file
144
cs440-acg/ext/eigen/bench/btl/libs/gmm/gmm_interface.hh
Normal file
@@ -0,0 +1,144 @@
|
||||
//=====================================================
|
||||
// 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 GMM_INTERFACE_HH
|
||||
#define GMM_INTERFACE_HH
|
||||
|
||||
#include <gmm/gmm.h>
|
||||
#include <vector>
|
||||
|
||||
using namespace gmm;
|
||||
|
||||
template<class real>
|
||||
class gmm_interface {
|
||||
|
||||
public :
|
||||
|
||||
typedef real real_type ;
|
||||
|
||||
typedef std::vector<real> stl_vector;
|
||||
typedef std::vector<stl_vector > stl_matrix;
|
||||
|
||||
typedef gmm::dense_matrix<real> gene_matrix;
|
||||
typedef stl_vector gene_vector;
|
||||
|
||||
static inline std::string name( void )
|
||||
{
|
||||
return "gmm";
|
||||
}
|
||||
|
||||
static void free_matrix(gene_matrix & A, int N){
|
||||
return ;
|
||||
}
|
||||
|
||||
static void free_vector(gene_vector & B){
|
||||
return ;
|
||||
}
|
||||
|
||||
static inline void matrix_from_stl(gene_matrix & A, stl_matrix & A_stl){
|
||||
A.resize(A_stl[0].size(),A_stl.size());
|
||||
|
||||
for (int j=0; j<A_stl.size() ; j++){
|
||||
for (int i=0; i<A_stl[j].size() ; i++){
|
||||
A(i,j) = A_stl[j][i];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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){
|
||||
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,j);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static inline void matrix_matrix_product(const gene_matrix & A, const gene_matrix & B, gene_matrix & X, int N){
|
||||
gmm::mult(A,B, X);
|
||||
}
|
||||
|
||||
static inline void transposed_matrix_matrix_product(const gene_matrix & A, const gene_matrix & B, gene_matrix & X, int N){
|
||||
gmm::mult(gmm::transposed(A),gmm::transposed(B), X);
|
||||
}
|
||||
|
||||
static inline void ata_product(const gene_matrix & A, gene_matrix & X, int N){
|
||||
gmm::mult(gmm::transposed(A),A, X);
|
||||
}
|
||||
|
||||
static inline void aat_product(const gene_matrix & A, gene_matrix & X, int N){
|
||||
gmm::mult(A,gmm::transposed(A), X);
|
||||
}
|
||||
|
||||
static inline void matrix_vector_product(gene_matrix & A, gene_vector & B, gene_vector & X, int N){
|
||||
gmm::mult(A,B,X);
|
||||
}
|
||||
|
||||
static inline void atv_product(gene_matrix & A, gene_vector & B, gene_vector & X, int N){
|
||||
gmm::mult(gmm::transposed(A),B,X);
|
||||
}
|
||||
|
||||
static inline void axpy(const real coef, const gene_vector & X, gene_vector & Y, int N){
|
||||
gmm::add(gmm::scaled(X,coef), Y);
|
||||
}
|
||||
|
||||
static inline void axpby(real a, const gene_vector & X, real b, gene_vector & Y, int N){
|
||||
gmm::add(gmm::scaled(X,a), gmm::scaled(Y,b), Y);
|
||||
}
|
||||
|
||||
static inline void copy_matrix(const gene_matrix & source, gene_matrix & cible, int N){
|
||||
gmm::copy(source,cible);
|
||||
}
|
||||
|
||||
static inline void copy_vector(const gene_vector & source, gene_vector & cible, int N){
|
||||
gmm::copy(source,cible);
|
||||
}
|
||||
|
||||
static inline void trisolve_lower(const gene_matrix & L, const gene_vector& B, gene_vector & X, int N){
|
||||
gmm::copy(B,X);
|
||||
gmm::lower_tri_solve(L, X, false);
|
||||
}
|
||||
|
||||
static inline void partial_lu_decomp(const gene_matrix & X, gene_matrix & R, int N){
|
||||
gmm::copy(X,R);
|
||||
std::vector<int> ipvt(N);
|
||||
gmm::lu_factor(R, ipvt);
|
||||
}
|
||||
|
||||
static inline void hessenberg(const gene_matrix & X, gene_matrix & R, int N){
|
||||
gmm::copy(X,R);
|
||||
gmm::Hessenberg_reduction(R,X,false);
|
||||
}
|
||||
|
||||
static inline void tridiagonalization(const gene_matrix & X, gene_matrix & R, int N){
|
||||
gmm::copy(X,R);
|
||||
gmm::Householder_tridiagonalization(R,X,false);
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif
|
||||
51
cs440-acg/ext/eigen/bench/btl/libs/gmm/main.cpp
Normal file
51
cs440-acg/ext/eigen/bench/btl/libs/gmm/main.cpp
Normal file
@@ -0,0 +1,51 @@
|
||||
//=====================================================
|
||||
// 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.
|
||||
//
|
||||
#include "utilities.h"
|
||||
#include "gmm_interface.hh"
|
||||
#include "bench.hh"
|
||||
#include "basic_actions.hh"
|
||||
#include "action_hessenberg.hh"
|
||||
#include "action_partial_lu.hh"
|
||||
|
||||
BTL_MAIN;
|
||||
|
||||
int main()
|
||||
{
|
||||
|
||||
bench<Action_axpy<gmm_interface<REAL_TYPE> > >(MIN_AXPY,MAX_AXPY,NB_POINT);
|
||||
bench<Action_axpby<gmm_interface<REAL_TYPE> > >(MIN_AXPY,MAX_AXPY,NB_POINT);
|
||||
|
||||
bench<Action_matrix_vector_product<gmm_interface<REAL_TYPE> > >(MIN_MV,MAX_MV,NB_POINT);
|
||||
bench<Action_atv_product<gmm_interface<REAL_TYPE> > >(MIN_MV,MAX_MV,NB_POINT);
|
||||
|
||||
bench<Action_matrix_matrix_product<gmm_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
// bench<Action_ata_product<gmm_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
// bench<Action_aat_product<gmm_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
|
||||
bench<Action_trisolve<gmm_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
//bench<Action_lu_solve<blitz_LU_solve_interface<REAL_TYPE> > >(MIN_LU,MAX_LU,NB_POINT);
|
||||
|
||||
bench<Action_partial_lu<gmm_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
|
||||
bench<Action_hessenberg<gmm_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
bench<Action_tridiagonalization<gmm_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
12
cs440-acg/ext/eigen/bench/btl/libs/mtl4/.kdbgrc.main
Normal file
12
cs440-acg/ext/eigen/bench/btl/libs/mtl4/.kdbgrc.main
Normal file
@@ -0,0 +1,12 @@
|
||||
[General]
|
||||
DebuggerCmdStr=
|
||||
DriverName=GDB
|
||||
FileVersion=1
|
||||
OptionsSelected=
|
||||
ProgramArgs=
|
||||
TTYLevel=7
|
||||
WorkingDirectory=
|
||||
|
||||
[Memory]
|
||||
ColumnWidths=80,0
|
||||
NumExprs=0
|
||||
6
cs440-acg/ext/eigen/bench/btl/libs/mtl4/CMakeLists.txt
Normal file
6
cs440-acg/ext/eigen/bench/btl/libs/mtl4/CMakeLists.txt
Normal file
@@ -0,0 +1,6 @@
|
||||
|
||||
find_package(MTL4)
|
||||
if (MTL4_FOUND)
|
||||
include_directories(${MTL4_INCLUDE_DIR})
|
||||
btl_add_bench(btl_mtl4 main.cpp)
|
||||
endif (MTL4_FOUND)
|
||||
46
cs440-acg/ext/eigen/bench/btl/libs/mtl4/main.cpp
Normal file
46
cs440-acg/ext/eigen/bench/btl/libs/mtl4/main.cpp
Normal file
@@ -0,0 +1,46 @@
|
||||
//=====================================================
|
||||
// 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.
|
||||
//
|
||||
#include "utilities.h"
|
||||
#include "mtl4_interface.hh"
|
||||
#include "bench.hh"
|
||||
#include "basic_actions.hh"
|
||||
#include "action_cholesky.hh"
|
||||
// #include "action_lu_decomp.hh"
|
||||
|
||||
BTL_MAIN;
|
||||
|
||||
int main()
|
||||
{
|
||||
|
||||
bench<Action_axpy<mtl4_interface<REAL_TYPE> > >(MIN_AXPY,MAX_AXPY,NB_POINT);
|
||||
bench<Action_axpby<mtl4_interface<REAL_TYPE> > >(MIN_AXPY,MAX_AXPY,NB_POINT);
|
||||
|
||||
bench<Action_matrix_vector_product<mtl4_interface<REAL_TYPE> > >(MIN_MV,MAX_MV,NB_POINT);
|
||||
bench<Action_atv_product<mtl4_interface<REAL_TYPE> > >(MIN_MV,MAX_MV,NB_POINT);
|
||||
bench<Action_matrix_matrix_product<mtl4_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
// bench<Action_ata_product<mtl4_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
// bench<Action_aat_product<mtl4_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
|
||||
bench<Action_trisolve<mtl4_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
// bench<Action_cholesky<mtl4_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
// bench<Action_lu_decomp<mtl4_interface<REAL_TYPE> > >(MIN_MM,MAX_MM,NB_POINT);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,192 @@
|
||||
//=====================================================
|
||||
// File : blitz_LU_solve_interface.hh
|
||||
// Author : L. Plagne <laurent.plagne@edf.fr)>
|
||||
// Copyright (C) EDF R&D, lun sep 30 14:23:31 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 BLITZ_LU_SOLVE_INTERFACE_HH
|
||||
#define BLITZ_LU_SOLVE_INTERFACE_HH
|
||||
|
||||
#include "blitz/array.h"
|
||||
#include <vector>
|
||||
|
||||
BZ_USING_NAMESPACE(blitz)
|
||||
|
||||
template<class real>
|
||||
class blitz_LU_solve_interface : public blitz_interface<real>
|
||||
{
|
||||
|
||||
public :
|
||||
|
||||
typedef typename blitz_interface<real>::gene_matrix gene_matrix;
|
||||
typedef typename blitz_interface<real>::gene_vector gene_vector;
|
||||
|
||||
typedef blitz::Array<int,1> Pivot_Vector;
|
||||
|
||||
inline static void new_Pivot_Vector(Pivot_Vector & pivot,int N)
|
||||
{
|
||||
|
||||
pivot.resize(N);
|
||||
|
||||
}
|
||||
|
||||
inline static void free_Pivot_Vector(Pivot_Vector & pivot)
|
||||
{
|
||||
|
||||
return;
|
||||
|
||||
}
|
||||
|
||||
|
||||
static inline real matrix_vector_product_sliced(const gene_matrix & A, gene_vector B, int row, int col_start, int col_end)
|
||||
{
|
||||
|
||||
real somme=0.;
|
||||
|
||||
for (int j=col_start ; j<col_end+1 ; j++){
|
||||
|
||||
somme+=A(row,j)*B(j);
|
||||
|
||||
}
|
||||
|
||||
return somme;
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
static inline real matrix_matrix_product_sliced(gene_matrix & A, int row, int col_start, int col_end, gene_matrix & B, int row_shift, int col )
|
||||
{
|
||||
|
||||
real somme=0.;
|
||||
|
||||
for (int j=col_start ; j<col_end+1 ; j++){
|
||||
|
||||
somme+=A(row,j)*B(j+row_shift,col);
|
||||
|
||||
}
|
||||
|
||||
return somme;
|
||||
|
||||
}
|
||||
|
||||
inline static void LU_factor(gene_matrix & LU, Pivot_Vector & pivot, int N)
|
||||
{
|
||||
|
||||
ASSERT( LU.rows()==LU.cols() ) ;
|
||||
int index_max = 0 ;
|
||||
real big = 0. ;
|
||||
real theSum = 0. ;
|
||||
real dum = 0. ;
|
||||
// Get the implicit scaling information :
|
||||
gene_vector ImplicitScaling( N ) ;
|
||||
for( int i=0; i<N; i++ ) {
|
||||
big = 0. ;
|
||||
for( int j=0; j<N; j++ ) {
|
||||
if( abs( LU( i, j ) )>=big ) big = abs( LU( i, j ) ) ;
|
||||
}
|
||||
if( big==0. ) {
|
||||
INFOS( "blitz_LU_factor::Singular matrix" ) ;
|
||||
exit( 0 ) ;
|
||||
}
|
||||
ImplicitScaling( i ) = 1./big ;
|
||||
}
|
||||
// Loop over columns of Crout's method :
|
||||
for( int j=0; j<N; j++ ) {
|
||||
for( int i=0; i<j; i++ ) {
|
||||
theSum = LU( i, j ) ;
|
||||
theSum -= matrix_matrix_product_sliced(LU, i, 0, i-1, LU, 0, j) ;
|
||||
// theSum -= sum( LU( i, Range( fromStart, i-1 ) )*LU( Range( fromStart, i-1 ), j ) ) ;
|
||||
LU( i, j ) = theSum ;
|
||||
}
|
||||
|
||||
// Search for the largest pivot element :
|
||||
big = 0. ;
|
||||
for( int i=j; i<N; i++ ) {
|
||||
theSum = LU( i, j ) ;
|
||||
theSum -= matrix_matrix_product_sliced(LU, i, 0, j-1, LU, 0, j) ;
|
||||
// theSum -= sum( LU( i, Range( fromStart, j-1 ) )*LU( Range( fromStart, j-1 ), j ) ) ;
|
||||
LU( i, j ) = theSum ;
|
||||
if( (ImplicitScaling( i )*abs( theSum ))>=big ) {
|
||||
dum = ImplicitScaling( i )*abs( theSum ) ;
|
||||
big = dum ;
|
||||
index_max = i ;
|
||||
}
|
||||
}
|
||||
// Interchanging rows and the scale factor :
|
||||
if( j!=index_max ) {
|
||||
for( int k=0; k<N; k++ ) {
|
||||
dum = LU( index_max, k ) ;
|
||||
LU( index_max, k ) = LU( j, k ) ;
|
||||
LU( j, k ) = dum ;
|
||||
}
|
||||
ImplicitScaling( index_max ) = ImplicitScaling( j ) ;
|
||||
}
|
||||
pivot( j ) = index_max ;
|
||||
if ( LU( j, j )==0. ) LU( j, j ) = 1.e-20 ;
|
||||
// Divide by the pivot element :
|
||||
if( j<N ) {
|
||||
dum = 1./LU( j, j ) ;
|
||||
for( int i=j+1; i<N; i++ ) LU( i, j ) *= dum ;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
inline static void LU_solve(const gene_matrix & LU, const Pivot_Vector pivot, gene_vector &B, gene_vector X, int N)
|
||||
{
|
||||
|
||||
// Pour conserver le meme header, on travaille sur X, copie du second-membre B
|
||||
X = B.copy() ;
|
||||
ASSERT( LU.rows()==LU.cols() ) ;
|
||||
firstIndex indI ;
|
||||
// Forward substitution :
|
||||
int ii = 0 ;
|
||||
real theSum = 0. ;
|
||||
for( int i=0; i<N; i++ ) {
|
||||
int ip = pivot( i ) ;
|
||||
theSum = X( ip ) ;
|
||||
// theSum = B( ip ) ;
|
||||
X( ip ) = X( i ) ;
|
||||
// B( ip ) = B( i ) ;
|
||||
if( ii ) {
|
||||
theSum -= matrix_vector_product_sliced(LU, X, i, ii-1, i-1) ;
|
||||
// theSum -= sum( LU( i, Range( ii-1, i-1 ) )*X( Range( ii-1, i-1 ) ) ) ;
|
||||
// theSum -= sum( LU( i, Range( ii-1, i-1 ) )*B( Range( ii-1, i-1 ) ) ) ;
|
||||
} else if( theSum ) {
|
||||
ii = i+1 ;
|
||||
}
|
||||
X( i ) = theSum ;
|
||||
// B( i ) = theSum ;
|
||||
}
|
||||
// Backsubstitution :
|
||||
for( int i=N-1; i>=0; i-- ) {
|
||||
theSum = X( i ) ;
|
||||
// theSum = B( i ) ;
|
||||
theSum -= matrix_vector_product_sliced(LU, X, i, i+1, N) ;
|
||||
// theSum -= sum( LU( i, Range( i+1, toEnd ) )*X( Range( i+1, toEnd ) ) ) ;
|
||||
// theSum -= sum( LU( i, Range( i+1, toEnd ) )*B( Range( i+1, toEnd ) ) ) ;
|
||||
// Store a component of the solution vector :
|
||||
X( i ) = theSum/LU( i, i ) ;
|
||||
// B( i ) = theSum/LU( i, i ) ;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif
|
||||
144
cs440-acg/ext/eigen/bench/btl/libs/mtl4/mtl4_interface.hh
Normal file
144
cs440-acg/ext/eigen/bench/btl/libs/mtl4/mtl4_interface.hh
Normal file
@@ -0,0 +1,144 @@
|
||||
//=====================================================
|
||||
// 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 MTL4_INTERFACE_HH
|
||||
#define MTL4_INTERFACE_HH
|
||||
|
||||
#include <boost/numeric/mtl/mtl.hpp>
|
||||
#include <boost/numeric/mtl/utility/range_generator.hpp>
|
||||
// #include <boost/numeric/mtl/operation/cholesky.hpp>
|
||||
#include <vector>
|
||||
|
||||
using namespace mtl;
|
||||
|
||||
template<class real>
|
||||
class mtl4_interface {
|
||||
|
||||
public :
|
||||
|
||||
typedef real real_type ;
|
||||
|
||||
typedef std::vector<real> stl_vector;
|
||||
typedef std::vector<stl_vector > stl_matrix;
|
||||
|
||||
typedef mtl::dense2D<real, mtl::matrix::parameters<mtl::tag::col_major> > gene_matrix;
|
||||
typedef mtl::dense_vector<real> gene_vector;
|
||||
|
||||
static inline std::string name() { return "mtl4"; }
|
||||
|
||||
static void free_matrix(gene_matrix & A, int N){
|
||||
return ;
|
||||
}
|
||||
|
||||
static void free_vector(gene_vector & B){
|
||||
return ;
|
||||
}
|
||||
|
||||
static inline void matrix_from_stl(gene_matrix & A, stl_matrix & A_stl){
|
||||
A.change_dim(A_stl[0].size(), A_stl.size());
|
||||
|
||||
for (int j=0; j<A_stl.size() ; j++){
|
||||
for (int i=0; i<A_stl[j].size() ; i++){
|
||||
A(i,j) = A_stl[j][i];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static inline void vector_from_stl(gene_vector & B, stl_vector & B_stl){
|
||||
B.change_dim(B_stl.size());
|
||||
for (int i=0; i<B_stl.size() ; i++){
|
||||
B[i] = B_stl[i];
|
||||
}
|
||||
}
|
||||
|
||||
static inline void vector_to_stl(gene_vector & B, stl_vector & B_stl){
|
||||
for (int i=0; i<B_stl.size() ; 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,j);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static inline void matrix_matrix_product(const gene_matrix & A, const gene_matrix & B, gene_matrix & X, int N){
|
||||
X = (A*B);
|
||||
// morton_dense<double, doppled_64_row_mask> C(N,N);
|
||||
// C = B;
|
||||
// X = (A*C);
|
||||
}
|
||||
|
||||
static inline void transposed_matrix_matrix_product(const gene_matrix & A, const gene_matrix & B, gene_matrix & X, int N){
|
||||
X = (trans(A)*trans(B));
|
||||
}
|
||||
|
||||
// static inline void ata_product(const gene_matrix & A, gene_matrix & X, int N){
|
||||
// X = (trans(A)*A);
|
||||
// }
|
||||
|
||||
static inline void aat_product(const gene_matrix & A, gene_matrix & X, int N){
|
||||
X = (A*trans(A));
|
||||
}
|
||||
|
||||
static inline void matrix_vector_product(gene_matrix & A, gene_vector & B, gene_vector & X, int N){
|
||||
X = (A*B);
|
||||
}
|
||||
|
||||
static inline void atv_product(gene_matrix & A, gene_vector & B, gene_vector & X, int N){
|
||||
X = (trans(A)*B);
|
||||
}
|
||||
|
||||
static inline void axpy(const real coef, const gene_vector & X, gene_vector & Y, int N){
|
||||
Y += coef * X;
|
||||
}
|
||||
|
||||
static inline void axpby(real a, const gene_vector & X, real b, gene_vector & Y, int N){
|
||||
Y = a*X + b*Y;
|
||||
}
|
||||
|
||||
// static inline void cholesky(const gene_matrix & X, gene_matrix & C, int N){
|
||||
// C = X;
|
||||
// recursive_cholesky(C);
|
||||
// }
|
||||
|
||||
// static inline void lu_decomp(const gene_matrix & X, gene_matrix & R, int N){
|
||||
// R = X;
|
||||
// std::vector<int> ipvt(N);
|
||||
// lu_factor(R, ipvt);
|
||||
// }
|
||||
|
||||
static inline void trisolve_lower(const gene_matrix & L, const gene_vector& B, gene_vector & X, int N){
|
||||
X = lower_trisolve(L, B);
|
||||
}
|
||||
|
||||
static inline void copy_matrix(const gene_matrix & source, gene_matrix & cible, int N){
|
||||
cible = source;
|
||||
}
|
||||
|
||||
static inline void copy_vector(const gene_vector & source, gene_vector & cible, int N){
|
||||
cible = source;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
#endif
|
||||
44
cs440-acg/ext/eigen/bench/btl/libs/tensors/CMakeLists.txt
Normal file
44
cs440-acg/ext/eigen/bench/btl/libs/tensors/CMakeLists.txt
Normal file
@@ -0,0 +1,44 @@
|
||||
|
||||
|
||||
if((NOT TENSOR_INCLUDE_DIR) AND Eigen_SOURCE_DIR)
|
||||
# unless TENSOR_INCLUDE_DIR is defined, let's use current Eigen version
|
||||
set(TENSOR_INCLUDE_DIR ${Eigen_SOURCE_DIR})
|
||||
set(TENSOR_FOUND TRUE)
|
||||
else()
|
||||
find_package(Tensor)
|
||||
endif()
|
||||
|
||||
if (TENSOR_FOUND)
|
||||
|
||||
include_directories(${TENSOR_INCLUDE_DIR})
|
||||
btl_add_bench(btl_tensor_linear main_linear.cpp)
|
||||
btl_add_bench(btl_tensor_vecmat main_vecmat.cpp)
|
||||
btl_add_bench(btl_tensor_matmat main_matmat.cpp)
|
||||
|
||||
btl_add_target_property(btl_tensor_linear COMPILE_FLAGS "-fno-exceptions -DBTL_PREFIX=tensor")
|
||||
btl_add_target_property(btl_tensor_vecmat COMPILE_FLAGS "-fno-exceptions -DBTL_PREFIX=tensor")
|
||||
btl_add_target_property(btl_tensor_matmat COMPILE_FLAGS "-fno-exceptions -DBTL_PREFIX=tensor")
|
||||
|
||||
option(BTL_BENCH_NOGCCVEC "also bench Eigen explicit vec without GCC's auto vec" OFF)
|
||||
if(CMAKE_COMPILER_IS_GNUCXX AND BTL_BENCH_NOGCCVEC)
|
||||
btl_add_bench(btl_tensor_nogccvec_linear main_linear.cpp)
|
||||
btl_add_bench(btl_tensor_nogccvec_vecmat main_vecmat.cpp)
|
||||
btl_add_bench(btl_tensor_nogccvec_matmat main_matmat.cpp)
|
||||
|
||||
btl_add_target_property(btl_tensor_nogccvec_linear COMPILE_FLAGS "-fno-exceptions -fno-tree-vectorize -DBTL_PREFIX=tensor_nogccvec")
|
||||
btl_add_target_property(btl_tensor_nogccvec_vecmat COMPILE_FLAGS "-fno-exceptions -fno-tree-vectorize -DBTL_PREFIX=tensor_nogccvec")
|
||||
btl_add_target_property(btl_tensor_nogccvec_matmat COMPILE_FLAGS "-fno-exceptions -fno-tree-vectorize -DBTL_PREFIX=tensor_nogccvec")
|
||||
endif()
|
||||
|
||||
|
||||
if(NOT BTL_NOVEC)
|
||||
btl_add_bench(btl_tensor_novec_linear main_linear.cpp OFF)
|
||||
btl_add_bench(btl_tensor_novec_vecmat main_vecmat.cpp OFF)
|
||||
btl_add_bench(btl_tensor_novec_matmat main_matmat.cpp OFF)
|
||||
btl_add_target_property(btl_tensor_novec_linear COMPILE_FLAGS "-fno-exceptions -DEIGEN_DONT_VECTORIZE -DBTL_PREFIX=tensor_novec")
|
||||
btl_add_target_property(btl_tensor_novec_vecmat COMPILE_FLAGS "-fno-exceptions -DEIGEN_DONT_VECTORIZE -DBTL_PREFIX=tensor_novec")
|
||||
btl_add_target_property(btl_tensor_novec_matmat COMPILE_FLAGS "-fno-exceptions -DEIGEN_DONT_VECTORIZE -DBTL_PREFIX=tensor_novec")
|
||||
|
||||
endif(NOT BTL_NOVEC)
|
||||
|
||||
endif (TENSOR_FOUND)
|
||||
23
cs440-acg/ext/eigen/bench/btl/libs/tensors/main_linear.cpp
Normal file
23
cs440-acg/ext/eigen/bench/btl/libs/tensors/main_linear.cpp
Normal file
@@ -0,0 +1,23 @@
|
||||
// This file is part of Eigen, a lightweight C++ template library
|
||||
// for linear algebra.
|
||||
//
|
||||
// Copyright (C) 2014 Benoit Steiner <benoit.steiner.goog@gmail.com>
|
||||
//
|
||||
// This Source Code Form is subject to the terms of the Mozilla
|
||||
// Public License v. 2.0. If a copy of the MPL was not distributed
|
||||
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
||||
|
||||
#include "utilities.h"
|
||||
#include "tensor_interface.hh"
|
||||
#include "bench.hh"
|
||||
#include "basic_actions.hh"
|
||||
|
||||
BTL_MAIN;
|
||||
|
||||
int main()
|
||||
{
|
||||
bench<Action_axpy<tensor_interface<REAL_TYPE> > >(MIN_AXPY,MAX_AXPY,NB_POINT);
|
||||
bench<Action_axpby<tensor_interface<REAL_TYPE> > >(MIN_AXPY,MAX_AXPY,NB_POINT);
|
||||
|
||||
return 0;
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user