├── .gitignore
├── include
    ├── Eigen
    └── .gitignore
├── src
    ├── algo
    │   ├── algo_common.hpp
    │   ├── cpu_algos.hpp
    │   ├── gpu_algos.hpp
    │   ├── cpu_algos.cpp
    │   └── gpu_algos.cpp
    ├── util
    │   ├── bit_tools.hpp
    │   ├── my_hash.hpp
    │   ├── primitive_structures.hpp
    │   ├── print_printable.hpp
    │   ├── lambda_compose.hpp
    │   ├── logging.cpp
    │   ├── id.hpp
    │   ├── utils.hpp
    │   └── logging.hpp
    ├── impl
    │   ├── impl_common.hpp
    │   ├── gpu_impl.hpp
    │   ├── cpu_impl.hpp
    │   ├── cpu_impl.cpp
    │   ├── gpu_impl.cu
    │   └── reduction_kernel.cu
    ├── cpu_only_main.cpp
    ├── gpu_cpu_main.cpp
    ├── run
    │   ├── common_ui.hpp
    │   └── common_ui.cpp
    ├── datastructures
    │   ├── tableau.hpp
    │   ├── problem.cpp
    │   └── problem.hpp
    └── Makefile
├── Makefile
├── LICENSE
├── README.md
├── enter-environment
└── notes.txt


/.gitignore:
--------------------------------------------------------------------------------
1 | /build/
2 | 


--------------------------------------------------------------------------------
/include/Eigen:
--------------------------------------------------------------------------------
1 | eigen-eigen-5a0156e40feb/Eigen


--------------------------------------------------------------------------------
/include/.gitignore:
--------------------------------------------------------------------------------
1 | eigen-eigen-5a0156e40feb
2 | 


--------------------------------------------------------------------------------
/src/algo/algo_common.hpp:
--------------------------------------------------------------------------------
1 | #ifndef ALGO__ALGO_COMMON_H
2 | #define ALGO__ALGO_COMMON_H
3 | 
4 | enum class TableauErrors {
5 | 	PROBLEM_UNBOUNDED,
6 | };
7 | 
8 | #endif /* ALGO__ALGO_COMMON_H */
9 | 


--------------------------------------------------------------------------------
/src/util/bit_tools.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef UTIL__BIT_TOOLS_H
 2 | #define UTIL__BIT_TOOLS_H
 3 | 
 4 | #include <type_traits>
 5 | 
 6 | namespace util {
 7 | 
 8 | 	template<typename DEST, typename SRC>
 9 | 	DEST no_sign_ext_cast(const SRC src) {
10 | 		return static_cast<DEST>(static_cast<std::make_unsigned_t<SRC>>(src));
11 | 	}
12 | 
13 | }
14 | 
15 | #endif // UTIL__BIT_TOOLS_H
16 | 


--------------------------------------------------------------------------------
/src/algo/cpu_algos.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef ALGO__CPU_ARGOS
 2 | #define ALGO__CPU_ARGOS
 3 | 
 4 | #include <datastructures/problem.hpp>
 5 | #include <algo/algo_common.hpp>
 6 | 
 7 | #include <boost/variant.hpp>
 8 | 
 9 | namespace simplex{
10 | 
11 | boost::variant<
12 | 	Assignments,
13 | 	TableauErrors
14 | > cpu_only_algo_from_paper(const Problem& problem);
15 | 
16 | } // end namespace simplex
17 | 
18 | #endif /* ALGO__CPU_ARGOS */
19 | 


--------------------------------------------------------------------------------
/src/algo/gpu_algos.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef ALGO__CPU_ARGOS
 2 | #define ALGO__CPU_ARGOS
 3 | 
 4 | #include <datastructures/problem.hpp>
 5 | #include <algo/algo_common.hpp>
 6 | 
 7 | #include <boost/variant.hpp>
 8 | 
 9 | namespace simplex{
10 | 
11 | boost::variant<
12 | 	Assignments,
13 | 	TableauErrors
14 | > gpu_cpu_algo_from_paper(const Problem& problem);
15 | 
16 | } // end namespace simplex
17 | 
18 | #endif /* ALGO__CPU_ARGOS */
19 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | 
 2 | SUBDIRS = src
 3 | 
 4 | # this recipe is for making the default target of the sub-makefiles
 5 | # the following should be a sufficiently "random" string to never cause any problems
 6 | default_target_maker_crdaeukntmouerdqjbhtrlchtbhrhckmcrhkbbhetkqn:
 7 | 	@for dir in $(SUBDIRS); do \
 8 | 		$(MAKE) -C $${dir} --no-print-directory; \
 9 | 	done
10 | 
11 | % :
12 | 	@for dir in $(SUBDIRS); do \
13 | 		$(MAKE) $@ -C $${dir} --no-print-directory; \
14 | 	done
15 | 


--------------------------------------------------------------------------------
/src/util/my_hash.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef UTIL__MY_HASH_H
 2 | #define UTIL__MY_HASH_H
 3 | 
 4 | #if __cplusplus >= 201103L
 5 | 
 6 | namespace std {
 7 | 	template<typename T>
 8 | 	struct hash;
 9 | }
10 | 
11 | namespace util {
12 | 
13 | template<class T, typename = void>
14 | struct MyHash {
15 | 	using type = std::hash<T>;
16 | };
17 | 
18 | template<class T>
19 | using MyHash_t = typename MyHash<T>::type;
20 | 
21 | template<template <typename... ARGS> class CONTAINER, typename KEY, typename... REST>
22 | using with_my_hash_t = CONTAINER<KEY, REST..., MyHash_t<KEY>>;
23 | 
24 | } // end namespace util
25 | 
26 | #endif
27 | 
28 | #endif // UTIL__MY_HASH_H
29 | 


--------------------------------------------------------------------------------
/src/impl/impl_common.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef IMPL__COMMON_INTERFACE
 2 | #define IMPL__COMMON_INTERFACE
 3 | 
 4 | #include <util/id.hpp>
 5 | // #include <cstdint>
 6 | 
 7 | #ifndef __CUDACC__
 8 | #include <iostream>
 9 | #endif
10 | 
11 | namespace simplex {
12 | 
13 | struct VariableIndexTag { static const int DEFAULT_VALUE = -1; };
14 | typedef util::ID<int, VariableIndexTag> VariableIndex;
15 | 
16 | #ifndef __CUDACC__
17 | inline std::ostream& operator<<(std::ostream& os, const VariableIndex& id) {
18 | 	os << "var" << id.getValue();
19 | 	return os;
20 | }
21 | #endif
22 | 
23 | struct VariablePair {
24 | 	VariableIndex entering;
25 | 	VariableIndex leaving;
26 | };
27 | 
28 | } // end namespace simplex
29 | 
30 | #endif /* IMPL__COMMON_INTERFACE */
31 | 


--------------------------------------------------------------------------------
/src/cpu_only_main.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <algo/cpu_algos.hpp>
 3 | #include <datastructures/tableau.hpp>
 4 | #include <run/common_ui.hpp>
 5 | #include <util/logging.hpp>
 6 | 
 7 | using simplex::cmdargs::ProgramConfig;
 8 | 
 9 | int program_main(const ProgramConfig& config);
10 | 
11 | int main(int argc, char const** argv) {
12 | 
13 | 	dout.setHighestTitleRank(7);
14 | 
15 | 	const auto parsed_args = simplex::cmdargs::parse(argc,argv);
16 | 	// enable logging levels
17 | 	for (auto& l : parsed_args.meta().getDebugLevelsToEnable()) {
18 | 		dout.enable_level(l);
19 | 	}
20 | 
21 | 	const auto result = program_main(parsed_args.programConfig());
22 | 
23 | 	return result;
24 | }
25 | 
26 | int program_main(const ProgramConfig& config) {
27 | 
28 | 	const auto& common_data = simplex::common_cmdline_ui(config);
29 | 	const auto& problem = common_data.problem;
30 | 
31 | 	auto result = cpu_only_algo_from_paper(problem);
32 | 	(void) result;
33 | 
34 | 	return 0;
35 | }


--------------------------------------------------------------------------------
/src/gpu_cpu_main.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <algo/gpu_algos.hpp>
 3 | #include <impl/gpu_impl.hpp>
 4 | #include <datastructures/tableau.hpp>
 5 | #include <run/common_ui.hpp>
 6 | #include <util/logging.hpp>
 7 | 
 8 | using simplex::cmdargs::ProgramConfig;
 9 | 
10 | int program_main(const ProgramConfig& config);
11 | 
12 | int main(int argc, char const** argv) {
13 | 
14 | 	dout.setHighestTitleRank(7);
15 | 
16 | 	const auto parsed_args = simplex::cmdargs::parse(argc,argv);
17 | 	// enable logging levels
18 | 	for (auto& l : parsed_args.meta().getDebugLevelsToEnable()) {
19 | 		dout.enable_level(l);
20 | 	}
21 | 
22 | 	auto config = parsed_args.programConfig();
23 | 	config.force_problem_padding = true; // GPU version requires padding
24 | 
25 | 	const auto result = program_main(config);
26 | 
27 | 	return result;
28 | }
29 | 
30 | int program_main(const ProgramConfig& config) {
31 | 
32 | 	const auto& common_data = simplex::common_cmdline_ui(config);
33 | 	const auto& problem = common_data.problem;
34 | 
35 | 	auto result = gpu_cpu_algo_from_paper(problem);
36 | 	(void) result;
37 | 
38 | 	return 0;
39 | }
40 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2020 Matthew Walker and Linda Shen
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # simplex-gpu
 2 | The simplex algorithm, implemented in Cuda and for CPU.
 3 | Uses Eigen for CPU implementation; Cuda (with some use of Thrust) for GPU code.
 4 | 
 5 | Implements and verifies the findings of
 6 | > M. E. Lalami, V. Boyer and D. El-Baz “Efficient Implementation of the Simplex Method on a CPU-GPU System”.
 7 | > In: 2011 IEEE International Symposium on Parallel and Distributed Processing Workshops and PhD Forum.
 8 | > May 2011, pp. 1999–2006.
 9 | > [doi:10.1109/IPDPS.2011.362](http://dx.doi.org/10.1109/IPDPS.2011.362)
10 | 
11 | Speedup is maximum 463x when comparing to the single-threaded CPU implementation,
12 | 	at the maximum tableau size that fits into the GPU memory (16384x16384, 2GiB).
13 | As reported by the paper, it was faster to
14 | 	perform the leaving and entering variable selections (reduction operations) on the CPU.
15 | 	
16 | ## Repository Layout
17 | High-level calls to algorithm components can be found in [src/algo](./src/algo),
18 | 	and component implementation can be found in [src/impl](./src/impl).
19 | 	
20 | ## Dependencies
21 |  - Install Thrust and Cuda
22 |  - Download and unpack Eigen in [include](./include) according to the version in the symlink there.
23 | 


--------------------------------------------------------------------------------
/src/util/primitive_structures.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef UTIL__PRIMITIVE_DATA_H
 2 | #define UTIL__PRIMITIVE_DATA_H
 3 | 
 4 | namespace util {
 5 | 
 6 | template<typename T>
 7 | class PointerAndSize {
 8 | public:
 9 | 	typedef std::ptrdiff_t Index;
10 | 	PointerAndSize(T* data, Index size)
11 | 		: m_data(data)
12 | 		, m_size(size)
13 | 	{ }
14 | 
15 | 	template<typename SRC>
16 | 	PointerAndSize(SRC& src)
17 | 		: m_data(src.data())
18 | 		, m_size(static_cast<Index>(src.size()))
19 | 	{ }
20 | 	
21 | 	T& at(Index i) { return m_data[i]; }
22 | 	const T& at(Index i) const { return m_data[i]; }
23 | 
24 | 	Index size() const { return m_size; }
25 | 	std::ptrdiff_t data_size() const { return size()*(std::ptrdiff_t)sizeof(T); }
26 | 
27 | 	T*& data() { return m_data; }
28 | 
29 | 	T* begin() { return m_data; }
30 | 	T* end() { return m_data + m_size; }
31 | 
32 | 	T const* begin() const { return m_data; }
33 | 	T const* end() const { return m_data + m_size; }
34 | 
35 | 	#pragma clang diagnostic push
36 | 	#pragma clang diagnostic ignored "-Wreturn-stack-address"
37 | 	// the following incorrectly gives a warning (known bug in clang 3.8)
38 | 	const T* const& data() const { return m_data; }
39 | 	#pragma clang diagnostic pop
40 | 
41 | 	T* m_data;
42 | 	Index m_size;
43 | };
44 | 
45 | } // end namespace util
46 | 
47 | #endif /* UTIL__PRIMITIVE_DATA_H */
48 | 


--------------------------------------------------------------------------------
/enter-environment:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | if [ ! -d "src" ] || [ ! -e "enter-environment" ]; then
 4 | 	echo "please execute in the top level directory; where src/ and enter-environment are"
 5 | 	exit 1;
 6 | fi
 7 | 
 8 | if [ -z "$SHELL" ]; then
 9 | 	echo "WARNING: \$SHELL not set, using bash"
10 | 	SHELL_EXE="bash";
11 | else
12 | 	SHELL_EXE="$SHELL";
13 | fi
14 | 
15 | if [ ! -z "$GPU_SIMPLEX_ROOTDIR" ]; then
16 | 	echo "WARNING: invocation from already initialized environment. Old GPU_SIMPLEX_ROOTDIR=$GPU_SIMPLEX_ROOTDIR";
17 | fi
18 | 
19 | export GPU_SIMPLEX_ROOTDIR="$(readlink --canonicalize "$PWD")/";
20 | export GPU_SIMPLEX_CPUBINDIR="$GPU_SIMPLEX_ROOTDIR/build/EXE/";
21 | export GPU_SIMPLEX_GPUBINDIR="$GPU_SIMPLEX_ROOTDIR/build/GPU_EXE/";
22 | export GPU_SIMPLEX_SCRIPTSDIR="$GPU_SIMPLEX_ROOTDIR/scripts/";
23 | export GPU_SIMPLEX_BENCHMARKDIR="$GPU_SIMPLEX_ROOTDIR/benchmarks/";
24 | 
25 | export PATH="$GPU_SIMPLEX_SCRIPTSDIR:$GPU_SIMPLEX_CPUBINDIR:$GPU_SIMPLEX_GPUBINDIR:$PATH"
26 | # export LD_LIBRARY_PATH="$(readlink --canonicalize ???):$LD_LIBRARY_PATH"
27 | 
28 | export HOST_COMPILER='clang-3.8'
29 | export CUDA_PATH='/usr/'
30 | 
31 | echo "Entering $SHELL_EXE with setup environment. GPU_SIMPLEX_ROOTDIR=$GPU_SIMPLEX_ROOTDIR";
32 | $SHELL_EXE
33 | echo "Exiting environment. Old GPU_SIMPLEX_ROOTDIR=$GPU_SIMPLEX_ROOTDIR";
34 | 
35 | 


--------------------------------------------------------------------------------
/notes.txt:
--------------------------------------------------------------------------------
 1 | make && simplex -r --random-problem-seed 2 --num-variables 1000 --num-constraints 1000 --constraint-density 0.8 --force-padding > gpu.out && tail gpu.out -n 2
 2 | 
 3 | 
 4 | 128
 5 | 256
 6 | 512
 7 | 1024
 8 | 2048
 9 | 4096
10 | 8192
11 | 16384
12 | 32768
13 | 65536
14 | 
15 | simplex -r --random-problem-seed 2 --num-variables 128 --num-constraints 128 --constraint-density 0.9 --force-padding > gpu.out && tail gpu.out -n 5
16 | simplex -r --random-problem-seed 2 --num-variables 256 --num-constraints 256 --constraint-density 0.9 --force-padding > gpu.out && tail gpu.out -n 5
17 | simplex -r --random-problem-seed 2 --num-variables 512 --num-constraints 512 --constraint-density 0.9 --force-padding > gpu.out && tail gpu.out -n 5
18 | simplex -r --random-problem-seed 2 --num-variables 1024 --num-constraints 1024 --constraint-density 0.9 --force-padding > gpu.out && tail gpu.out -n 5
19 | simplex -r --random-problem-seed 2 --num-variables 2048 --num-constraints 2048 --constraint-density 0.9 --force-padding > gpu.out && tail gpu.out -n 5
20 | simplex -r --random-problem-seed 2 --num-variables 4096 --num-constraints 4096 --constraint-density 0.9 --force-padding > gpu.out && tail gpu.out -n 5
21 | simplex -r --random-problem-seed 2 --num-variables 8192 --num-constraints 8192 --constraint-density 0.9 --force-padding > gpu.out && tail gpu.out -n 5
22 | 


--------------------------------------------------------------------------------
/src/util/print_printable.hpp:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifndef UTIL__PRINT_PRINTABLE_HPP
 3 | #define UTIL__PRINT_PRINTABLE_HPP
 4 | 
 5 | // #include <iosfwd>
 6 | // #include <tuple>
 7 | 
 8 | namespace util {
 9 | 
10 | // TODO: maybe provide some sort of default? maybe one that gives a warning when compiled?
11 | struct print_printable { };
12 | 
13 | 
14 | #if __cplusplus >= 201103L
15 | 
16 | template<typename T, typename STREAM>
17 | auto operator<<(STREAM& os, const T& t) -> decltype(static_cast<const print_printable*>(&t),os) {
18 | 	t.print(os);
19 | 	return os;
20 | }
21 | 
22 | template<typename T, typename STREAM>
23 | auto operator<<(STREAM& os, const T& t) -> decltype(static_cast<const print_printable*>(&t.get()),os) {
24 | 	t.get().print(os);
25 | 	return os;
26 | }
27 | 
28 | template<typename T>
29 | struct print_with_printable{
30 | 	using print_with_type = T;
31 | };
32 | 
33 | #endif
34 | 
35 | // template<typename T, typename U>
36 | // auto operator<<(std::ostream& os, const std::tuple<T&,U&>& pair) -> decltype(static_cast<const print_with_printable<U>*>(&std::get<0>(pair)),os) {
37 | // 	std::get<0>(pair).print(os, std::get<1>(pair));
38 | // 	return os;
39 | // }
40 | 
41 | // template<typename T, typename U>
42 | // auto operator<<(std::ostream& os, const std::tuple<T&,U&>& pair) -> decltype(static_cast<const print_with_printable<U>*>(&std::get<0>(pair).get()),os) {
43 | // 	std::get<0>(pair).get().print(os, std::get<1>(pair));
44 | // 	return os;
45 | // }
46 | 
47 | } // end namespace util
48 | 
49 | #endif /* UTIL__PRINT_PRINTABLE_HPP */
50 | 


--------------------------------------------------------------------------------
/src/impl/gpu_impl.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef IMLP__GPU_IMPL_H
 2 | #define IMLP__GPU_IMPL_H
 3 | 
 4 | // #include <datastructures/problem.hpp>
 5 | #include <datastructures/tableau.hpp>
 6 | #include <impl/impl_common.hpp>
 7 | #include <util/primitive_structures.hpp>
 8 | 
 9 | #include <cuda_runtime.h>
10 | 
11 | namespace simplex {
12 | namespace gpu {
13 | 
14 | template<typename FloatType>
15 | struct ThetaValuesAndEnteringColumn {
16 | 	util::PointerAndSize<FloatType> theta_values;
17 | 	util::PointerAndSize<FloatType> entering_column;
18 | 
19 | 	ThetaValuesAndEnteringColumn(std::ptrdiff_t height)
20 | 		: theta_values(NULL, height)
21 | 		, entering_column(NULL, height)
22 | 	{
23 | 		cudaMalloc(&theta_values.data(), static_cast<std::size_t>(theta_values.data_size()));
24 | 		cudaMalloc(&entering_column.data(), static_cast<std::size_t>(entering_column.data_size()));
25 | 	}
26 | 
27 | 	// ThetaValuesAndEnteringColumn(const ThetaValuesAndEnteringColumn&) = default;
28 | 	// ThetaValuesAndEnteringColumn(ThetaValuesAndEnteringColumn&&) = default;
29 | };
30 | 
31 | // Tableau<double> create_tableau(const Problem& problem_stmt);
32 | 
33 | // find smallest also negative value in the first row
34 | // boost::optional<VariableIndex> find_entering_variable(const Tableau<double>& tab);
35 | 
36 | struct ProblemContraints {
37 | 	std::ptrdiff_t height_modulus;
38 | 	std::ptrdiff_t  width_modulus;
39 | };
40 | 
41 | ptrdiff_t find_entering_variable(const util::PointerAndSize<double>& first_row);
42 | 
43 | ThetaValuesAndEnteringColumn<double> get_theta_values_and_entering_column(const Tableau<double>& tab, VariableIndex entering);
44 | 
45 | ptrdiff_t find_leaving_variable(const ThetaValuesAndEnteringColumn<double>& tvals_and_centering);
46 | 
47 | void update_leaving_row(Tableau<double>& tab, const util::PointerAndSize<double>& entering_column, VariablePair leaving_and_entering);
48 | 
49 | void update_rest_of_basis(Tableau<double>& tab, const util::PointerAndSize<double>& entering_column, VariableIndex leaving);
50 | 
51 | void update_entering_column(Tableau<double>& tab, const util::PointerAndSize<double>& entering_column, VariablePair leaving_and_entering);
52 | 
53 | ProblemContraints problem_constraints();
54 | 
55 | } // end namespace simplex
56 | } // end namespace gpu
57 | 
58 | #endif /* IMLP__GPU_IMPL_H */
59 | 


--------------------------------------------------------------------------------
/src/run/common_ui.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef PARSING__CMDARGS_H
 2 | #define PARSING__CMDARGS_H
 3 | 
 4 | #include <util/logging.hpp>
 5 | #include <datastructures/problem.hpp>
 6 | 
 7 | #include <string>
 8 | 
 9 | #include <boost/optional.hpp>
10 | 
11 | namespace simplex {
12 | namespace cmdargs {
13 | 
14 | struct ParsedArguments;
15 | 
16 | struct MetaConfig {
17 | 	/**
18 | 	 * Return the list of debug levels that shold be enabled given the command line options
19 | 	 * NOTE: May contain duplicates.
20 | 	 */
21 | 	const std::vector<DebugLevel::Level> getDebugLevelsToEnable() const {
22 | 		return levels_to_enable;
23 | 	}
24 | 
25 | private:
26 | 	friend struct ParsedArguments;
27 | 	friend ParsedArguments parse(int arc_int, char const** argv);
28 | 
29 | 	MetaConfig();
30 | 
31 | 	/// The printing levels that should be enabled. Duplicate entries are possible & allowed
32 | 	std::vector<DebugLevel::Level> levels_to_enable;
33 | };
34 | 
35 | struct ProgramConfig {
36 | 	friend struct ParsedArguments;
37 | 	friend ParsedArguments parse(int arc_int, char const** argv);
38 | 
39 | 	ProgramConfig();
40 | 
41 | 	std::string m_dataFileName;
42 | 	int m_nThreads;
43 | 
44 | 	bool use_random_problem;
45 | 	boost::optional<unsigned long> random_problem_seed;
46 | 	boost::optional<int> num_variables;
47 | 	boost::optional<int> num_constraints;
48 | 	boost::optional<double> constraint_density;
49 | 	bool force_problem_padding;
50 | 
51 | 	boost::optional<std::string> problem_dump_filename;
52 | };
53 | 
54 | struct ParsedArguments {
55 | 	const MetaConfig& meta() const { return m_meta; }
56 | 	const ProgramConfig& programConfig() const { return m_programConfig; }
57 | 
58 | private:
59 | 	friend ParsedArguments parse(int arc_int, char const** argv);
60 | 
61 | 	MetaConfig m_meta;
62 | 	ProgramConfig m_programConfig;
63 | 
64 | 	ParsedArguments(int arc_int, char const** argv);
65 | };
66 | 
67 | /**
68 |  * call this function to parse and return a ParsedArguments object from the
69 |  * arguments, which then can be queried about the various options.
70 |  */
71 | ParsedArguments parse(int arc_int, char const** argv);
72 | 
73 | } // end namespace cmdargs
74 | 
75 | struct CommonCmdlineData {
76 | 	Problem problem;
77 | };
78 | 
79 | CommonCmdlineData common_cmdline_ui(const cmdargs::ProgramConfig& config);
80 | 
81 | } // end namespace simplex
82 | 
83 | #endif /* PARSING__CMDARGS_H */
84 | 


--------------------------------------------------------------------------------
/src/util/lambda_compose.hpp:
--------------------------------------------------------------------------------
 1 | 
 2 | #ifndef UTIL__LAMBDA_VISITOR_H
 3 | #define UTIL__LAMBDA_VISITOR_H
 4 | 
 5 | // from a stack overflow answer
 6 | // TODO: find the link when I have internet
 7 | 
 8 | #include <functional>
 9 | #include <type_traits>
10 | 
11 | namespace util {
12 | 
13 | namespace detail {
14 | 
15 | 	template<typename... Lambdas>
16 | 	struct composed_lambda;
17 | 
18 | 	template<typename Lambda1, typename... Lambdas>
19 | 	struct composed_lambda<Lambda1, Lambdas...>
20 | 		: public composed_lambda<Lambdas...>,
21 | 		  public Lambda1
22 | 	{
23 | 		using Lambda1::operator ();
24 | 		using composed_lambda<Lambdas...>::operator ();
25 | 
26 | 		composed_lambda(Lambda1 l1, Lambdas... lambdas)
27 | 			: composed_lambda<Lambdas...>(lambdas...)
28 | 			, Lambda1(l1)
29 | 		{ }
30 | 	};
31 | 
32 | 	template<typename Lambda1>
33 | 	struct composed_lambda<Lambda1> : public Lambda1 {
34 | 		using Lambda1::operator ();
35 | 
36 | 		composed_lambda(Lambda1 l1)
37 | 			: Lambda1(l1)
38 | 		{ }
39 | 	};
40 | 
41 | 	template<typename BASE, typename... Lambdas>
42 | 	struct composed_lambda_withbase;
43 | 
44 | 	template<typename BASE, typename Lambda1, typename... Lambdas>
45 | 	struct composed_lambda_withbase<BASE, Lambda1, Lambdas...>
46 | 		: public composed_lambda_withbase<BASE, Lambdas...>,
47 | 		  public Lambda1
48 | 	{
49 | 		using Lambda1::operator ();
50 | 		using composed_lambda_withbase<BASE, Lambdas...>::operator ();
51 | 
52 | 		composed_lambda_withbase(Lambda1 l1, Lambdas... lambdas)
53 | 			: composed_lambda_withbase<BASE, Lambdas...>(lambdas...)
54 | 			, Lambda1(l1)
55 | 		{ }
56 | 	};
57 | 
58 | 	template<typename BASE, typename Lambda1>
59 | 	struct composed_lambda_withbase<BASE, Lambda1> : public Lambda1, public BASE {
60 | 		using Lambda1::operator ();
61 | 
62 | 		composed_lambda_withbase(Lambda1 l1)
63 | 			: Lambda1(l1)
64 | 		{ }
65 | 	};
66 | }
67 | 
68 | template<typename... Fs>
69 | auto compose(Fs&& ...fs) {
70 | 	using composed_type = detail::composed_lambda<std::decay_t<Fs>...>;
71 | 	return composed_type(std::forward<Fs>(fs)...);
72 | }
73 | 
74 | template<typename BASE, typename... Fs>
75 | auto compose_withbase(Fs&& ...fs) {
76 | 	using composed_type = detail::composed_lambda_withbase<BASE, std::decay_t<Fs>...>;
77 | 	return composed_type(std::forward<Fs>(fs)...);
78 | }
79 | 
80 | } // end namespace util
81 | 
82 | #endif // UTIL__LAMBDA_VISITOR_H
83 | 


--------------------------------------------------------------------------------
/src/datastructures/tableau.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef DATASTRUCTURES__TABLEAU_H
 2 | #define DATASTRUCTURES__TABLEAU_H
 3 | 
 4 | #include <impl/impl_common.hpp>
 5 | #include <util/print_printable.hpp>
 6 | 
 7 | namespace simplex {
 8 | 
 9 | template<typename FloatType>
10 | class Tableau : public util::print_printable {
11 | public:
12 | 	Tableau(FloatType* data, std::ptrdiff_t height, std::ptrdiff_t width)
13 | 		: m_data_width(width)
14 | 		, m_data_height(height)
15 | 		, m_width(width)
16 | 		, m_height(height)
17 | 		, m_data(data)
18 | 	{ }
19 | 
20 | 	const FloatType& at(std::ptrdiff_t row, std::ptrdiff_t col) const { return m_data[indexof(row,col)]; }
21 | 	      FloatType& at(std::ptrdiff_t row, std::ptrdiff_t col)       { return m_data[indexof(row,col)]; }
22 | 
23 | 	const FloatType& at(std::ptrdiff_t row, VariableIndex col) const { return at(row, col.getValue()); }
24 | 	      FloatType& at(std::ptrdiff_t row, VariableIndex col)       { return at(row, col.getValue()); }
25 | 
26 | 	const FloatType& at(VariableIndex row, std::ptrdiff_t col) const { return at(row.getValue(), col); }
27 | 	      FloatType& at(VariableIndex row, std::ptrdiff_t col)       { return at(row.getValue(), col); }
28 | 
29 | 	const FloatType& at(VariableIndex row, VariableIndex col) const { return at(row.getValue(), col.getValue()); }
30 | 	      FloatType& at(VariableIndex row, VariableIndex col)       { return at(row.getValue(), col.getValue()); }
31 | 
32 | 	const FloatType& cost() const { return at(0,0); }
33 | 
34 | 	std::size_t indexof(std::ptrdiff_t row, std::ptrdiff_t col) const { return static_cast<std::size_t>(row*m_data_width + col); }
35 | 
36 | 	std::ptrdiff_t width() const { return m_width; }
37 | 	std::ptrdiff_t height() const { return m_height; }
38 | 
39 | 	FloatType*& data() { return m_data; }
40 | 	FloatType* const& data() const { return m_data; }
41 | 	std::ptrdiff_t data_size() const { return m_data_width*m_data_height*(std::ptrdiff_t)sizeof(FloatType); }
42 | 
43 | 	template<typename STREAM>
44 | 	void print(STREAM& os) const {
45 | 		for (std::ptrdiff_t irow = 0; irow < height(); ++irow) {
46 | 			for (std::ptrdiff_t icol = 0; icol < width(); ++icol) {
47 | 				os << ' ' << at(irow, icol);
48 | 			}
49 | 			if (irow != height() - 1) {
50 | 				os << '\n';
51 | 			}
52 | 		}
53 | 	}
54 | 
55 | private:
56 | 	std::ptrdiff_t m_data_width;
57 | 	std::ptrdiff_t m_data_height;
58 | 	std::ptrdiff_t m_width;
59 | 	std::ptrdiff_t m_height;
60 | 	FloatType* m_data;
61 | };
62 | 
63 | } // end namespace simplex
64 | 
65 | #endif /* DATASTRUCTURES__TABLEAU_H */
66 | 


--------------------------------------------------------------------------------
/src/impl/cpu_impl.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef IMLP__CPU_IMPL_H
 2 | #define IMLP__CPU_IMPL_H
 3 | 
 4 | #include <datastructures/problem.hpp>
 5 | #include <datastructures/tableau.hpp>
 6 | #include <impl/impl_common.hpp>
 7 | #include <util/primitive_structures.hpp>
 8 | #include <util/print_printable.hpp>
 9 | 
10 | #include <vector>
11 | 
12 | #include <boost/optional.hpp>
13 | 
14 | namespace simplex {
15 | namespace cpu {
16 | 
17 | #if __cplusplus >= 201103L
18 | template<typename FloatType>
19 | struct ThetaValuesAndEnteringColumn : util::print_printable {
20 | 	std::vector<FloatType> theta_values;
21 | 	std::vector<FloatType> entering_column;
22 | 
23 | 	ThetaValuesAndEnteringColumn(std::ptrdiff_t height)
24 | 		: theta_values((std::size_t)height)
25 | 		, entering_column((std::size_t)height)
26 | 	{ }
27 | 
28 | 	ThetaValuesAndEnteringColumn(const ThetaValuesAndEnteringColumn&) = default;
29 | 	ThetaValuesAndEnteringColumn(ThetaValuesAndEnteringColumn&&) = default;
30 | 	ThetaValuesAndEnteringColumn& operator=(const ThetaValuesAndEnteringColumn&) = default;
31 | 	ThetaValuesAndEnteringColumn& operator=(ThetaValuesAndEnteringColumn&&) = default;
32 | 
33 | 	template<typename STREAM>
34 | 	void print(STREAM& os) const {
35 | 		os << "{tv = {";
36 | 		for (const auto& tv : theta_values) {
37 | 			os << tv << ", ";
38 | 		}
39 | 		os << "}, ec = {";
40 | 		for (const auto& ecv : entering_column) {
41 | 			os << ecv << ", ";
42 | 		}
43 | 		os << "}}";
44 | 	}
45 | };
46 | #endif
47 | 
48 | Tableau<double> create_tableau(const Problem& problem_stmt);
49 | 
50 | // find smallest also negative value in the first row
51 | boost::optional<VariableIndex> find_entering_variable(const util::PointerAndSize<double>& first_row);
52 | 
53 | ThetaValuesAndEnteringColumn<double> get_theta_values_and_entering_column(const Tableau<double>& tab, VariableIndex entering);
54 | 
55 | boost::optional<VariableIndex> find_leaving_variable(const ThetaValuesAndEnteringColumn<double>& tvals_and_centering);
56 | 
57 | #if __cplusplus >= 201103L
58 | Tableau<double> update_leaving_row(Tableau<double>&& tab, const std::vector<double>& entering_column, VariablePair leaving_and_entering);
59 | 
60 | Tableau<double> update_rest_of_basis(Tableau<double>&& tab, const std::vector<double>& entering_column, VariableIndex leaving);
61 | 
62 | Tableau<double> update_entering_column(Tableau<double>&& tab, const std::vector<double>& entering_column, VariablePair leaving_and_entering);
63 | #endif
64 | 
65 | } // end namespace simplex
66 | } // end namespace cpu
67 | 
68 | #endif /* IMLP__CPU_IMPL_H */
69 | 


--------------------------------------------------------------------------------
/src/algo/cpu_algos.cpp:
--------------------------------------------------------------------------------
 1 | #include "cpu_algos.hpp"
 2 | 
 3 | #include <impl/cpu_impl.hpp>
 4 | #include <util/logging.hpp>
 5 | #include <chrono>
 6 | 
 7 | namespace simplex{
 8 | 
 9 | boost::variant<
10 | 	Assignments,
11 | 	TableauErrors
12 | > cpu_only_algo_from_paper(const Problem& problem) {
13 | 	using cpu::create_tableau;
14 | 	using cpu::find_entering_variable;
15 | 	using cpu::get_theta_values_and_entering_column;
16 | 	using cpu::find_leaving_variable;
17 | 	using cpu::update_leaving_row;
18 | 	using cpu::update_rest_of_basis;
19 | 	using cpu::update_entering_column;
20 | 
21 | 	const auto indent = dout(DL::INFO).indentWithTitle("Algorithm from the Paper (CPU)");
22 | 	auto tableau = create_tableau(problem);
23 | 	int iteration_num = 1;
24 | 
25 | 	double total_time = 0;
26 | 	while (true) {
27 | 		auto start = std::chrono::system_clock::now();;
28 | 
29 | 		const auto indent = dout(DL::INFO).indentWithTitle([&](auto&& s){ s << "Iteration " << iteration_num; });
30 | 		dout(DL::DBG1) << "tableau:\n" << tableau << '\n';
31 | 
32 | 		const auto entering_var = find_entering_variable(util::PointerAndSize<double>(tableau.data(), tableau.width()));
33 | 
34 | 		if (!entering_var) {
35 | 			dout(DL::INFO) << "Solution reached!\n";
36 | 			break;
37 | 		}
38 | 		
39 | 		const auto tv_and_centering = get_theta_values_and_entering_column(tableau, *entering_var);
40 | 		
41 | 		const auto leaving_var = find_leaving_variable(tv_and_centering);
42 | 
43 | 		if (!leaving_var) {
44 | 			dout(DL::INFO) << "Problem is unbounded!\n";
45 | 			break;
46 | 		}
47 | 
48 | 		VariablePair entering_and_leaving = {
49 | 			*entering_var,
50 | 			*leaving_var,
51 | 		};
52 | 
53 | 		tableau = update_entering_column(
54 | 			update_rest_of_basis(
55 | 				update_leaving_row(
56 | 					std::move(tableau),
57 | 					tv_and_centering.entering_column,
58 | 					entering_and_leaving
59 | 				),
60 | 				tv_and_centering.entering_column,
61 | 				entering_and_leaving.leaving
62 | 			),
63 | 			tv_and_centering.entering_column,
64 | 			entering_and_leaving
65 | 		);
66 | 
67 | 		iteration_num += 1;
68 | 
69 | 		auto finish = std::chrono::system_clock::now();
70 | 		std::chrono::duration<double> elapsed_seconds = finish-start;
71 | 		total_time += elapsed_seconds.count();
72 | 
73 | 		if (iteration_num == 10000) break;
74 | 	}
75 | 
76 | 	{const auto indent = dout(DL::INFO).indentWithTitle("Result");
77 | 		dout(DL::INFO) << tableau << '\n';
78 | 	}
79 | 
80 | 	delete tableau.data();
81 | 
82 | 	double average_time = total_time/(iteration_num-1);
83 | 	std::cout << "total_time: " << total_time <<  "\n";
84 | 	std::cout << "average_time: " << average_time <<  "\n";
85 | 
86 | 	return Assignments{};
87 | }
88 | 
89 | } // end namespace simplex
90 | 


--------------------------------------------------------------------------------
/src/util/logging.cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | #include "logging.hpp"
  3 | 
  4 | 
  5 | IndentingLeveledDebugPrinter dout(std::cout, 0);
  6 | 
  7 | 
  8 | namespace DebugLevel {
  9 | 	std::vector<Level> getDefaultSet() {
 10 | 		return {
 11 | 			INFO,WARN,ERROR
 12 | 		};
 13 | 	}
 14 | 
 15 | 	std::vector<Level> getStandardDebug() {
 16 | 		return {
 17 | 			DBG1,
 18 | 			DATA_READ1,
 19 | 		};
 20 | 	}
 21 | 
 22 | 	/**
 23 | 	 * The enable chains.
 24 | 	 * if a level is in one of these, then it and all the ones after it
 25 | 	 * will be returned by getAllShouldBeEnabled(...).
 26 | 	 * a given Level may appear in multiple chains.
 27 | 	 */
 28 | 	std::vector<std::vector<Level>> enable_chains {
 29 | 		{ DBG4, DBG3, DBG2, DBG1, },
 30 | 		{ LINDA, },
 31 | 	};
 32 | 
 33 | 	std::vector<Level> getAllShouldBeEnabled(Level l) {
 34 | 		std::vector<Level> retset;
 35 | 		for (auto& enable_chain : enable_chains) {
 36 | 			// find the Level
 37 | 			auto it = std::find(begin(enable_chain),end(enable_chain),l);
 38 | 			// insert *it and the ones after
 39 | 			// if it == .end() (ie. l was not found), then nothing happens!
 40 | 			retset.insert(retset.end(),it,enable_chain.end());
 41 | 		}
 42 | 		return retset;
 43 | 	}
 44 | 
 45 | 	std::vector<std::pair<Level,std::string>> levels_and_strings {
 46 | 		{ INFO,  "INFO"  },
 47 | 		{ WARN,  "WARN"  },
 48 | 		{ ERROR, "ERROR" },
 49 | 
 50 | 		{ DBG1,  "DBG1" },
 51 | 		{ DBG2,  "DBG2" },
 52 | 		{ DBG3,  "DBG3" },
 53 | 		{ DBG4,  "DBG4" },
 54 | 		{ LINDA,  "LINDA" },
 55 | 
 56 | 		{ DATA_READ1, "DATA_READ1" },
 57 | 	};
 58 | 
 59 | 	std::pair<Level,bool> getFromString(std::string str) {
 60 | 		// linear search is probably fine
 61 | 		for (auto& pair : levels_and_strings) {
 62 | 			if (str == pair.second) {
 63 | 				return {pair.first,true};
 64 | 			}
 65 | 		}
 66 | 		return {Level::LEVEL_COUNT,false};
 67 | 	}
 68 | 
 69 | 	std::string getAsString(Level l) {
 70 | 		// linear search is probably fine
 71 | 		for (auto& pair : levels_and_strings) {
 72 | 			if (l == pair.first) {
 73 | 				return pair.second;
 74 | 			}
 75 | 		}
 76 | 
 77 | 		dout(DL::WARN) << "trying to get the name of a level "
 78 | 			"that doesn't have an associated string ( value = " << l << " )\n"
 79 | 		;
 80 | 
 81 | 		return "";
 82 | 	}
 83 | 
 84 | }
 85 | 
 86 | LevelStream::~LevelStream() {
 87 | 	// when the caller is done, dump the ss to src;
 88 | 	flush();
 89 | }
 90 | 
 91 | void LevelStream::flush() {
 92 | 	if (enabled()) {
 93 | 		src->print(underlying_ss);
 94 | 	}
 95 | 	underlying_ss.clear();
 96 | }
 97 | 
 98 | void IndentLevel::endIndent() {
 99 | 	ended = true;
100 | 	if (src) {
101 | 		src->endIndent();
102 | 	}
103 | }
104 | 
105 | IndentLevel::~IndentLevel() {
106 | 	if (src && !ended) {
107 | 		src->endIndent();
108 | 	}
109 | }
110 | 


--------------------------------------------------------------------------------
/src/util/id.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef UTIL__ID_H
  2 | #define UTIL__ID_H
  3 | 
  4 | #include <util/my_hash.hpp>
  5 | 
  6 | #include <climits>
  7 | #include <utility>
  8 | 
  9 | namespace util {
 10 | 
 11 | class IDBase {
 12 | public:
 13 | 	int getValue() const;
 14 | 	template<typename STREAM> void print(STREAM& os);
 15 | };
 16 | 
 17 | template<typename id_type, typename TAG>
 18 | class ID : public IDBase {
 19 | 	id_type value;
 20 | protected:
 21 | 
 22 | #if __cplusplus >= 201103L
 23 | 	template<typename ID_TYPE, typename... ARGS>
 24 | 	friend auto make_id(ARGS&&... args) -> typename std::enable_if<
 25 | 		std::is_base_of<typename ID_TYPE::ThisIDType,ID_TYPE>::value,
 26 | 		ID_TYPE
 27 | 	>::type;
 28 | #endif
 29 | public:
 30 | 	explicit ID(const id_type& value) : value(value) { }
 31 | 	typedef id_type IDType;
 32 | 	typedef ID<id_type,TAG> ThisIDType;
 33 | 	const static id_type DEFAULT_VALUE = TAG::DEFAULT_VALUE;
 34 | 	// constexpr static unsigned long long BIT_SIZE = static_cast<unsigned long long>(sizeof(IDType)*CHAR_BIT);
 35 | 	// constexpr static unsigned long long JUST_HIGH_BIT = static_cast<unsigned long long>(static_cast<IDType>(1) << (BIT_SIZE-1));
 36 | 
 37 | 	ID() : value(TAG::DEFAULT_VALUE) { }
 38 | 	// ID(const ID&) = default;
 39 | 	// ID(ID&&) = default;
 40 | 
 41 | 	// ID& operator=(const ID&) = default;
 42 | 	// ID& operator=(ID&&) = default;
 43 | 
 44 | 	explicit operator id_type() const { return value; }
 45 | 	id_type getValue() const { return value; }
 46 | 	template<typename STREAM> void print(STREAM& os) { os << value; }
 47 | };
 48 | 
 49 | 
 50 | #if __cplusplus >= 201103L
 51 | template<typename ID_TYPE, typename... ARGS>
 52 | auto make_id(ARGS&&... args) -> typename std::enable_if<
 53 | 	std::is_base_of<typename ID_TYPE::ThisIDType,ID_TYPE>::value,
 54 | 	ID_TYPE
 55 | >::type {
 56 | 	return ID_TYPE(std::forward<ARGS>(args)...);
 57 | }
 58 | 
 59 | template<typename ID>
 60 | class IDGenerator {
 61 | 	typedef typename ID::IDType IDType;
 62 | 
 63 | 	IDType next_id_value;
 64 | public:
 65 | 	IDGenerator(IDType first_value)
 66 | 		: next_id_value(first_value)
 67 | 	{ }
 68 | 
 69 | 	ID gen_id() {
 70 | 		ID id = make_id<ID>(next_id_value);
 71 | 		++next_id_value;
 72 | 		return id;
 73 | 	}
 74 | };
 75 | 
 76 | template<typename... ARGS>
 77 | IDGenerator<ARGS...> make_id_generator(ARGS&&... args) {
 78 | 	return IDGenerator<ARGS...>(std::forward<ARGS>(args)...);
 79 | }
 80 | 
 81 | template<typename id_type, typename TAG>
 82 | bool operator==(const ID<id_type,TAG>& lhs, const ID<id_type,TAG>& rhs) {
 83 | 	return (id_type)lhs == (id_type)rhs;
 84 | }
 85 | 
 86 | template<typename id_type, typename TAG>
 87 | bool operator!=(const ID<id_type,TAG>& lhs, const ID<id_type,TAG>& rhs) {
 88 | 	return !(lhs == rhs);
 89 | }
 90 | 
 91 | 
 92 | 
 93 | template<class T, typename = void>
 94 | struct IDHasher;
 95 | 
 96 | template<class T>
 97 | struct IDHasher<T, typename std::enable_if<std::is_base_of<IDBase, T>::value>::type> {
 98 | 	std::size_t operator()(const T& id) const {
 99 | 		return std::hash<decltype(id.getValue())>()(id.getValue());
100 | 	}
101 | };
102 | 
103 | template<class T>
104 | struct MyHash<T, typename std::enable_if<std::is_base_of<IDBase, T>::value>::type> {
105 | 	using type = IDHasher<T>;
106 | };
107 | 
108 | #endif
109 | 
110 | } // end namespace util
111 | 
112 | #endif // UTIL__ID_H
113 | 


--------------------------------------------------------------------------------
/src/datastructures/problem.cpp:
--------------------------------------------------------------------------------
 1 | #include "problem.hpp"
 2 | 
 3 | #include <random>
 4 | 
 5 | namespace simplex {
 6 | 
 7 | Problem generate_random_problem(const RandomProblemSpecification& prob_spec) {
 8 | 	const auto seed = prob_spec.random_seed.value_or(std::random_device()());
 9 | 	auto prob_spec_with_seed = prob_spec;
10 | 	prob_spec_with_seed.random_seed = seed;
11 | 	Problem p(prob_spec_with_seed);
12 | 
13 | 	std::mt19937 rgen{seed};
14 | 	std::uniform_real_distribution<> random_chance_dist          (   0.0,   1.0);
15 | 	std::uniform_real_distribution<> random_constr_coeff_dist    (prob_spec.constr_coeff_range.first,     prob_spec.constr_coeff_range.second);
16 | 	std::uniform_real_distribution<> random_constr_rhs_coeff_dist(prob_spec.constr_rhs_coeff_range.first, prob_spec.constr_rhs_coeff_range.second);
17 | 	std::uniform_real_distribution<> random_objfunc_coeff_dist   (prob_spec.objfunc_coeff_range.first,    prob_spec.objfunc_coeff_range.second);
18 | 	const auto random_chance            = [&]() { return random_chance_dist          (rgen); };
19 | 	const auto random_constr_coeff      = [&]() { return random_constr_coeff_dist    (rgen); };
20 | 	const auto random_constr_rhs_coeff  = [&]() { return random_constr_rhs_coeff_dist(rgen); };
21 | 	const auto random_objfunc_coeff     = [&]() { return random_objfunc_coeff_dist   (rgen); };
22 | 
23 | 	std::vector<std::pair<VariableID, Problem::FloatType>> constraint;
24 | 	for (int iconstr = 0; iconstr < prob_spec.num_constraints; ++iconstr) {
25 | 		constraint.clear();
26 | 		for (int ivar = 0; ivar < prob_spec.num_variables; ++ivar) {
27 | 			if (random_chance() < prob_spec.density) {
28 | 				constraint.emplace_back(util::make_id<VariableID>(ivar), random_constr_coeff());
29 | 			} else {
30 | 				constraint.emplace_back(util::make_id<VariableID>(ivar), 0);
31 | 			}
32 | 		}
33 | 		p.add_constraint(constraint, random_constr_rhs_coeff());
34 | 	}
35 | 
36 | 	for (int ivar = 0; ivar < prob_spec.num_variables; ++ivar) {
37 | 		const auto var = util::make_id<VariableID>(ivar);
38 | 		if (p.has_variable(var)) {
39 | 			p.set_cost(var, random_objfunc_coeff());
40 | 		}
41 | 	}
42 | 
43 | 	return p;
44 | }
45 | 
46 | Problem make_small_sample_problem() {
47 | 	Problem p;
48 | 
49 | 	const auto v0 = util::make_id<VariableID>(0);
50 | 	const auto v1 = util::make_id<VariableID>(1);
51 | 	const auto v2 = util::make_id<VariableID>(2);
52 | 	p.add_constraint(
53 | 		std::vector<std::pair<VariableID, Problem::FloatType>>{
54 | 			{ v0, 1 },
55 | 			{ v1, 3 },
56 | 			{ v2, 2 },
57 | 		},
58 | 		10
59 | 	);
60 | 
61 | 	p.add_constraint(
62 | 		std::vector<std::pair<VariableID, Problem::FloatType>>{
63 | 			{ v0, 3 },
64 | 			{ v1, 2 },
65 | 			{ v2, 5 },
66 | 		},
67 | 		15
68 | 	);
69 | 
70 | 	p.set_cost(v0, 4);
71 | 	p.set_cost(v1, 2);
72 | 	p.set_cost(v2, 3);
73 | 
74 | 	return p;
75 | }
76 | 
77 | Problem pad_with_zeroes_modulo(Problem&& p, std::ptrdiff_t height_modulus, std::ptrdiff_t width_modulus) {
78 | 	// +1 is for the special 0th row and col
79 | 	const std::ptrdiff_t rows_to_pad = (height_modulus - ((1 + p.num_constraints()) % height_modulus)) % height_modulus;
80 | 	const std::ptrdiff_t cols_to_pad = ( width_modulus - ((1 + p.num_variables())   %  width_modulus)) %  width_modulus;
81 | 
82 | 	std::vector<std::pair<VariableID, Problem::FloatType>> empty_constraint_with_new_vars;
83 | 	for (const auto vid_and_vprop : p.variables()) {
84 | 		empty_constraint_with_new_vars.emplace_back(vid_and_vprop.first, 0);
85 | 	}
86 | 
87 | 	for (std::ptrdiff_t i = 0; i < cols_to_pad; ++i) {
88 | 		empty_constraint_with_new_vars.emplace_back(util::make_id<VariableID>(p.num_variables() + i), 0);
89 | 	}
90 | 
91 | 	for (std::ptrdiff_t i = 0; i < rows_to_pad; ++i) {
92 | 		p.add_constraint(empty_constraint_with_new_vars, 0);
93 | 	}
94 | 
95 | 	return p;
96 | }
97 | 
98 | } // end namespace simplex
99 | 


--------------------------------------------------------------------------------
/src/run/common_ui.cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | #include "common_ui.hpp"
  3 | 
  4 | #include <impl/gpu_impl.hpp>
  5 | 
  6 | #include <fstream>
  7 | #include <unordered_set>
  8 | 
  9 | #include <boost/program_options.hpp>
 10 | 
 11 | namespace boost {
 12 | 	template<class T>
 13 | 	void validate(boost::any& v, std::vector<std::string> const& values, boost::optional<T>*, int) {
 14 | 	    if (!values.empty()) {
 15 | 	        boost::any a;
 16 | 	        using namespace boost::program_options;
 17 | 	        validate(a, values, (T*)0, 0);
 18 | 	        v = boost::any(boost::optional<T>(boost::any_cast<T>(a)));
 19 | 	    }
 20 | 	}
 21 | }
 22 | 
 23 | namespace simplex {
 24 | namespace cmdargs {
 25 | 
 26 | MetaConfig::MetaConfig()
 27 | 	: levels_to_enable(DebugLevel::getDefaultSet())
 28 | { }
 29 | 
 30 | ProgramConfig::ProgramConfig()
 31 | 	: m_dataFileName()
 32 | 	, m_nThreads(1)
 33 | 	, use_random_problem(false)
 34 | 	, random_problem_seed()
 35 | 	, num_variables()
 36 | 	, num_constraints()
 37 | 	, constraint_density()
 38 | 	, force_problem_padding(false)
 39 | 	, problem_dump_filename()
 40 | { }
 41 | 
 42 | 
 43 | ParsedArguments::ParsedArguments(int argc_int, char const** argv)
 44 | 	: m_meta()
 45 | 	, m_programConfig()
 46 | {
 47 | 	namespace po = boost::program_options;
 48 | 
 49 | 	po::options_description metaopts("Meta Options");
 50 | 	po::options_description progopts("Program Options");
 51 | 
 52 | 	metaopts.add_options()
 53 | 		("debug",    "Turn on the most common debugging options")
 54 | 	;
 55 | 	DebugLevel::forEachLevel([&](DebugLevel::Level l) {
 56 | 		metaopts.add_options()(("DL::" + DebugLevel::getAsString(l)).c_str(), "debug flag");
 57 | 	});
 58 | 
 59 | 	progopts.add_options()
 60 | 		("help,h", "print help message")
 61 | 		// ("file", po::value(&m_programConfig.m_dataFileName)->required(), "The file to use")
 62 | 		// ("num-threads", po::value(&m_programConfig.m_nThreads), "The maximum nuber of simultaneous threads to use")
 63 | 		("random-problem,r", po::bool_switch(&m_programConfig.use_random_problem), "Generate a random problem")
 64 | 		("random-problem-seed,s", po::value(&m_programConfig.random_problem_seed), "(Optional) random seed for random problem generation")
 65 | 		("num-variables", po::value(&m_programConfig.num_variables), "Number of variables in random problem")
 66 | 		("num-constraints", po::value(&m_programConfig.num_constraints), "Number of constraints in random problem")
 67 | 		("constraint-density", po::value(&m_programConfig.constraint_density), "Chance that a given variable in included in a constraint")
 68 | 		("force-padding", po::bool_switch(&m_programConfig.force_problem_padding), "Force padding the problem with zeroes to match GPU implementation constraints")
 69 | 		("dump-problem", po::value(&m_programConfig.problem_dump_filename), "Before starting the solve, save the problem in this file")
 70 | 	;
 71 | 
 72 | 	po::options_description allopts;
 73 | 	allopts.add(progopts).add(metaopts);
 74 | 
 75 | 	po::variables_map vm;
 76 | 	po::store(po::parse_command_line(argc_int, argv, allopts), vm);
 77 | 
 78 | 	// check for help flag before call to notify - don't care about required arguments in this case.
 79 | 	if (vm.count("help")) {
 80 | 		std::cerr << allopts << std::endl;
 81 | 		exit(0);
 82 | 	}
 83 | 
 84 | 	po::notify(vm);
 85 | 
 86 | 	if (vm.count("debug")) {
 87 | 		auto debug_levels = DebugLevel::getStandardDebug();
 88 | 		m_meta.levels_to_enable.insert(end(m_meta.levels_to_enable),begin(debug_levels),end(debug_levels));
 89 | 	}
 90 | 
 91 | 	DebugLevel::forEachLevel([&](DebugLevel::Level l) {
 92 | 		if (vm.count("DL::" + DebugLevel::getAsString(l))) {
 93 | 			auto levels_in_chain = DebugLevel::getAllShouldBeEnabled(l);
 94 | 			m_meta.levels_to_enable.insert(end(m_meta.levels_to_enable),begin(levels_in_chain),end(levels_in_chain));
 95 | 		}
 96 | 	});
 97 | }
 98 | 
 99 | ParsedArguments parse(int arc_int, char const** argv) {
100 | 	return ParsedArguments(arc_int, argv);
101 | }
102 | 
103 | } // end namespace cmdargs
104 | 
105 | CommonCmdlineData common_cmdline_ui(const cmdargs::ProgramConfig& config) {
106 | 	auto problem = [&]() {
107 | 		if (config.use_random_problem) {
108 | 			simplex::RandomProblemSpecification rps(*config.num_variables, *config.num_constraints);
109 | 			rps.density = *config.constraint_density;
110 | 			rps.random_seed = config.random_problem_seed;
111 | 			dout(DL::INFO) << "A random problem will be generated with these parameters: " << rps << '\n';
112 | 			if (config.force_problem_padding) {
113 | 				const auto problem_constraints = simplex::gpu::problem_constraints();
114 | 				return pad_with_zeroes_modulo(
115 | 					generate_random_problem(rps),
116 | 					problem_constraints.height_modulus,
117 | 					problem_constraints.width_modulus
118 | 				);
119 | 			} else {
120 | 				return generate_random_problem(rps);
121 | 			}
122 | 		} else {
123 | 			return simplex::make_small_sample_problem();
124 | 		}
125 | 	}();
126 | 
127 | 	if (config.problem_dump_filename) {
128 | 		std::ofstream prob_dumpfile(*config.problem_dump_filename);
129 | 		prob_dumpfile << problem << '\n';
130 | 	}
131 | 
132 | 	return {
133 | 		problem,
134 | 	};
135 | }
136 | 
137 | } // end namespace simplex
138 | 


--------------------------------------------------------------------------------
/src/datastructures/problem.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef DATASTRUCTURES__PROBLEM_H
  2 | #define DATASTRUCTURES__PROBLEM_H
  3 | 
  4 | #include <util/id.hpp>
  5 | #include <util/my_hash.hpp>
  6 | #include <util/print_printable.hpp>
  7 | 
  8 | #include <unordered_map>
  9 | #include <vector>
 10 | 
 11 | #include <boost/optional.hpp>
 12 | 
 13 | namespace simplex {
 14 | 
 15 | struct VariableIDTag { static const std::ptrdiff_t DEFAULT_VALUE = -1; };
 16 | typedef util::ID<std::ptrdiff_t, VariableIDTag> VariableID;
 17 | 
 18 | class RandomProblemSpecification : public util::print_printable {
 19 | public:
 20 | 	using FloatType = double;
 21 | 
 22 | 	RandomProblemSpecification(int num_variables, int num_constraints)
 23 | 		: num_variables(num_variables)
 24 | 		, num_constraints(num_constraints)
 25 | 	{ }
 26 | 
 27 | 	template<typename STREAM>
 28 | 	void print(STREAM& os) const {
 29 | 		os
 30 | 			<< "{ num_variables = " << num_variables
 31 | 			<< ", num_constraints = " << num_constraints
 32 | 			<< ", random_seed = "; if (random_seed) os << *random_seed; else os << "none"; os
 33 | 			<< ", density = " << density
 34 | 			<< ", constr_coeff_range = {" << constr_coeff_range.first << " - " << constr_coeff_range.second << "}"
 35 | 			<< ", constr_rhs_coeff_range = {" << constr_rhs_coeff_range.first << " - " << constr_rhs_coeff_range.second << "}"
 36 | 			<< ", objfunc_coeff_range = {" << objfunc_coeff_range.first << " - " << objfunc_coeff_range.second << "}"
 37 | 			<< " }"
 38 | 		;
 39 | 	}
 40 | 
 41 | 	int num_variables;
 42 | 	int num_constraints;
 43 | 
 44 | 	boost::optional<unsigned long> random_seed = {};
 45 | 
 46 | 	FloatType density = 0.8;
 47 | 	std::pair<FloatType, FloatType> constr_coeff_range     = {-100.0, 100.0};
 48 | 	std::pair<FloatType, FloatType> constr_rhs_coeff_range = {-100.0, 100.0};
 49 | 	std::pair<FloatType, FloatType> objfunc_coeff_range    = {-100.0, 100.0};
 50 | };
 51 | 
 52 | class Problem : public util::print_printable {
 53 | public:
 54 | 	using FloatType = double;
 55 | 
 56 | 	Problem(boost::optional<RandomProblemSpecification> spec_for_gen = {})
 57 | 		: m_spec_for_gen(spec_for_gen)
 58 | 	{ }
 59 | 
 60 | 	std::ptrdiff_t num_variables() const { if(m_max_var_id) return m_max_var_id->getValue() + 1; else return 0; }
 61 | 	std::ptrdiff_t num_constraints() const { return static_cast<std::ptrdiff_t>(m_constraints.size()); }
 62 | 
 63 | 	auto& constraints() const { return m_constraints; }
 64 | 	auto& variables()   const { return m_variables; }
 65 | 	auto& spec_for_gen() const { return m_spec_for_gen; }
 66 | 
 67 | 	template<typename CONSTRAINTS>
 68 | 	void add_constraint(CONSTRAINTS&& c, FloatType rhs) {
 69 | 		m_constraints.emplace_back(rhs);
 70 | 		auto& new_constr = m_constraints.back();
 71 | 		for (const auto& r : c) {
 72 | 			m_variables[r.first];
 73 | 			m_max_var_id = m_max_var_id.value_or(r.first);
 74 | 			m_max_var_id = r.first.getValue() > m_max_var_id->getValue() ? r.first : m_max_var_id;
 75 | 			new_constr.m_coeffs.emplace_back(r.first, r.second);
 76 | 		}
 77 | 	}
 78 | 
 79 | 	void set_cost(VariableID var, FloatType coeff) {
 80 | 		m_variables.at(var).m_coeff = coeff;
 81 | 	}
 82 | 
 83 | 	bool has_variable(VariableID var) {
 84 | 		return m_variables.find(var) != end(m_variables);
 85 | 	}
 86 | 
 87 | 	/* Prints the file in LP format */
 88 | 	template<typename STREAM>
 89 | 	void print(STREAM& os) const {
 90 | 		const auto& print_term = [&](auto& coeff, auto&& vid) {
 91 | 			os << (coeff >= 0 ? "+" : "") << coeff << " x" << vid.getValue() << ' ';
 92 | 		};
 93 | 
 94 | 		if (spec_for_gen()) {
 95 | 			// only link comments supported. Will break if spec print is multiline.
 96 | 			os << "\\ Generated with: " << spec_for_gen() << "\n";
 97 | 		}
 98 | 
 99 | 		os << "Maximize\n\t";
100 | 		for (const auto vid_and_vinf : variables()) {
101 | 			print_term(vid_and_vinf.second.m_coeff, vid_and_vinf.first);
102 | 		}
103 | 
104 | 		os << "\n\nSubject to\n";
105 | 		for (const auto& c : constraints()) {
106 | 			os << '\t';
107 | 			for (const auto vid_and_vinf : c.m_coeffs) {
108 | 				print_term(vid_and_vinf.second, vid_and_vinf.first);
109 | 			}
110 | 			os << "<= " << c.m_rhs << '\n';
111 | 		}
112 | 
113 | 		os << "\nBounds\n";
114 | 		os << "\nEnd";
115 | 	}
116 | 
117 | private:
118 | 	struct VariableProperties {
119 | 		struct hasher { std::size_t operator()(const VariableProperties& vp) const { return std::hash<FloatType>()(vp.m_coeff); } };
120 | 		FloatType m_coeff = 0;
121 | 	};
122 | 
123 | 	struct Constraint {
124 | 		Constraint(FloatType rhs)
125 | 			: m_coeffs()
126 | 			, m_rhs(rhs)
127 | 		{ }
128 | 
129 | 		std::vector<std::pair<VariableID, FloatType>> m_coeffs;
130 | 		FloatType m_rhs;
131 | 	};
132 | 
133 | 	std::unordered_map<VariableID, VariableProperties, typename util::MyHash<VariableID>::type> m_variables = {};
134 | 	std::vector<Constraint> m_constraints = {};
135 | 	boost::optional<VariableID> m_max_var_id = {};
136 | 	boost::optional<RandomProblemSpecification> m_spec_for_gen;
137 | };
138 | 
139 | class Assignments {
140 | 
141 | };
142 | 
143 | Problem generate_random_problem(const RandomProblemSpecification& prob_spec);
144 | 
145 | Problem make_small_sample_problem();
146 | 
147 | Problem pad_with_zeroes_modulo(Problem&& p, std::ptrdiff_t height_modulus, std::ptrdiff_t width_modulus);
148 | 
149 | } // end namespace simplex
150 | 
151 | #endif /* DATASTRUCTURES__PROBLEM_H */
152 | 


--------------------------------------------------------------------------------
/src/Makefile:
--------------------------------------------------------------------------------
  1 | 
  2 | # add parallelism equal to number of cores every time.
  3 | # it seems that adding -jX to MAKEFLAGS directly doesn't work any more.
  4 | # included some "random" strings to ensure uniqueness
  5 | ifneq ($(PARALELL_WRAPPER_ABXCOEOEKCOEBMQJKHTOEUB),done)
  6 | 
  7 | NUM_CORES ?= $(shell grep -c "vendor_id" /proc/cpuinfo)
  8 | MAKEFLAGS +=" -j$(NUM_CORES) -l$(NUM_CORES) "
  9 | 
 10 | # for the default target case
 11 | parallel_wrapper_default_target_anthsqjkshbeohcbmeuthnoethoaeou:
 12 | 	@$(MAKE) PARALELL_WRAPPER_ABXCOEOEKCOEBMQJKHTOEUB=done
 13 | 
 14 | # catches everything else
 15 | % :
 16 | 	@$(MAKE) $@ PARALELL_WRAPPER_ABXCOEOEKCOEBMQJKHTOEUB=done
 17 | 
 18 | # the match for this else is at the end of the file
 19 | else
 20 | 
 21 | .PHONY: all clean build_info
 22 | 
 23 | # remove ALL implicit rules & all suffixes
 24 | MAKEFLAGS+=" -r"
 25 | 
 26 | BUILD_MODE ?= release
 27 | 
 28 | BUILD_DIR = ../build/
 29 | EXE_DIR  = $(BUILD_DIR)EXE/
 30 | GPU_EXE  = $(BUILD_DIR)GPU_EXE/
 31 | OBJ_DIR  = $(BUILD_DIR)OBJ/
 32 | DEPS_DIR = $(BUILD_DIR)DEPS/
 33 | 
 34 | BUILD_SUBDIRS = $(EXE_DIR) $(GPU_EXE) $(OBJ_DIR) $(DEPS_DIR)
 35 | 
 36 | CXX = clang++-3.8
 37 | # CXX = g++
 38 | 
 39 | # put warning flags here - go to compiler *and* linker.
 40 | WARNING_FLAGS += -Wall -Wextra -pedantic -Weffc++ -Wconversion
 41 | 
 42 | # put other flags for both the compiler & linker here
 43 | EXTRA_FLAGS = -std=c++14
 44 | 
 45 | # add flags for debugging
 46 | ifeq ($(BUILD_MODE),debug)
 47 | 	EXTRA_FLAGS += -ggdb -D DEBUG # -D _GLIBCXX_DEBUG
 48 | endif
 49 | 
 50 | # add flags for release
 51 | ifeq ($(BUILD_MODE),release)
 52 | 	EXTRA_FLAGS += -O3
 53 | endif
 54 | 
 55 | LIBRARY_LINK_FLAGS += \
 56 | 	-lboost_program_options \
 57 | 	-lstdc++ \
 58 | 
 59 | 
 60 | INCLUDE_FLAGS += \
 61 | 	-I . \
 62 | 	-isystem ../include \
 63 | 
 64 | 
 65 | CXXFLAGS += $(EXTRA_FLAGS) $(WARNING_FLAGS) $(INCLUDE_FLAGS)
 66 | LDFLAGS  += $(EXTRA_FLAGS) $(WARNING_FLAGS) $(LIBRARY_LINK_FLAGS)
 67 | 
 68 | GPUCC = nvcc
 69 | GPU_EXTRA_FLAGS += -ccbin clang-3.8 -Wno-deprecated-gpu-targets --compiler-options -Wno-c++11-extensions
 70 | GPU_LIBRARY_LINK_FLAGS += -lm $(LIBRARY_LINK_FLAGS)
 71 | GPU_INCLUDE_FLAGS += $(INCLUDE_FLAGS)
 72 | GPUCCFLAGS += $(GPU_EXTRA_FLAGS) $(GPU_WARNING_FLAGS) $(GPU_INCLUDE_FLAGS)
 73 | GPULDFLAGS += $(GPU_EXTRA_FLAGS) $(GPU_WARNING_FLAGS) $(GPU_LIBRARY_LINK_FLAGS)
 74 | 
 75 | # keep .o files
 76 | .PRECIOUS: $(OBJ_DIR)%.o
 77 | 
 78 | # define source directories
 79 | SOURCE_DIRS = algo/ datastructures/ impl/ run/ util/ ./
 80 | 
 81 | ALL_OBJ_DIRS  = $(addprefix $(OBJ_DIR),  $(SOURCE_DIRS))
 82 | ALL_DEPS_DIRS = $(addprefix $(DEPS_DIR), $(SOURCE_DIRS))
 83 | 
 84 | # compute all directories that might need creation
 85 | DIRS= \
 86 | 	$(ALL_OBJ_DIRS) \
 87 | 	$(ALL_DEPS_DIRS) \
 88 | 	$(BUILD_SUBDIRS) \
 89 | 	$(BUILD_DIR)
 90 | 
 91 | # define executables
 92 | TEST_EXES=
 93 | EXES=$(GPU_EXE)simplex-cpu-only $(GPU_EXE)simplex $(TEST_EXES)
 94 | 
 95 | all: $(EXES) test | build_info
 96 | 
 97 | test: $(patsubst %, run_%, $(TEST_EXES))
 98 | 
 99 | build_info:
100 | 	@echo "Building with makeflags ${MAKEFLAGS}"
101 | 	@echo "In build mode ${BUILD_MODE}"
102 | 
103 | # add more dependencies here:
104 | $(GPU_EXE)simplex-cpu-only: \
105 | 	$(OBJ_DIR)algo/cpu_algos.o \
106 | 	$(OBJ_DIR)datastructures/problem.o \
107 | 	$(OBJ_DIR)impl/cpu_impl.o \
108 | 	$(OBJ_DIR)run/common_ui.o \
109 | 	$(OBJ_DIR)util/logging.o \
110 | 	$(OBJ_DIR)cpu_only_main.o \
111 | 	$(OBJ_DIR)impl/gpu_impl.o \
112 | 
113 | 
114 | $(GPU_EXE)simplex: \
115 | 	$(OBJ_DIR)algo/gpu_algos.o \
116 | 	$(OBJ_DIR)datastructures/problem.o \
117 | 	$(OBJ_DIR)impl/cpu_impl.o \
118 | 	$(OBJ_DIR)impl/gpu_impl.o \
119 | 	$(OBJ_DIR)run/common_ui.o \
120 | 	$(OBJ_DIR)util/logging.o \
121 | 	$(OBJ_DIR)gpu_cpu_main.o \
122 | 
123 | 
124 | # include all the dependency files, if any exist
125 | EXISTING_DEP_FILES = \
126 | 	$(foreach dir,$(SOURCE_DIRS), \
127 | 		$(wildcard $(DEPS_DIR)$(dir)*.d) \
128 | 	)
129 | ifneq (,$(EXISTING_DEP_FILES))
130 | include $(EXISTING_DEP_FILES)
131 | endif
132 | 
133 | # compile .c++ to .o
134 | # second CC line generates the initial dependency file
135 | # first sed line adds $(OBJ_DIR) prefixes to the dependency file,
136 | # second one adds stub rules for each depended on file (make might
137 | # complain with generated files)
138 | .SECONDEXPANSION:
139 | $(OBJ_DIR)%.o: %.cpp | build_info $(OBJ_DIR)$$(dir %) $(DEPS_DIR)$$(dir %)
140 | 	'$(CXX)' -c  '$(shell readlink --canonicalize $<)' -o  '$@' $(CXXFLAGS)
141 | 	@'$(CXX)' -MM '$<' -MF '$(DEPS_DIR)$<.d.tmp' $(CXXFLAGS)
142 | 	@sed -e 's|.*:|$@:|' < '$(DEPS_DIR)$<.d.tmp' > '$(DEPS_DIR)$<.d'
143 | 	@sed -e 's/.*://' -e 's/\\$$//' < '$(DEPS_DIR)$<.d.tmp'| fmt -1 | \
144 | 	 sed -e 's/^ *//' -e 's/$$/:/' >> '$(DEPS_DIR)$<.d'
145 | 	@rm -f $(DEPS_DIR)$<.d.tmp
146 | 
147 | .SECONDEXPANSION:
148 | $(OBJ_DIR)%.o: %.cu | build_info $(OBJ_DIR)$$(dir %)
149 | 	'$(GPUCC)' -c  '$(shell readlink --canonicalize $<)' -o  '$@' $(GPUCCFLAGS)
150 | 
151 | $(GPU_EXE)%: | build_info $(GPU_EXE)
152 | 	'$(GPUCC)' $(filter %.o,$^) -o '$@' $(GPULDFLAGS)
153 | 
154 | $(EXE_DIR)%: | build_info $(EXE_DIR)
155 | 	'$(CXX)' $(filter %.o,$^) -o '$@' $(LDFLAGS)
156 | 
157 | $(patsubst %, run_%, $(EXES)): $$(patsubst run_%, %, $$(@))
158 | 	@( $^ && echo "SUCCESS: $^" ) || echo "FAIL: $^"
159 | 
160 | $(DIRS):
161 | 	mkdir -p $@
162 | 
163 | clean: $(BUILD_DIR:%=delete_%_dir)
164 | 
165 | $(patsubst %, delete_%_dir, $(BUILD_DIR)    ): $$(patsubst %, delete_%_dir, $(BUILD_SUBDIRS))
166 | $(patsubst %, delete_%_dir, $(OBJ_DIR)      ): $$(patsubst %, delete_%_dir, $$(ALL_OBJ_DIRS))
167 | $(patsubst %, delete_%_dir, $(DEPS_DIR)     ): $$(patsubst %, delete_%_dir, $$(ALL_DEPS_DIRS))
168 | $(patsubst %, delete_%_dir, $(EXE_DIR)      ): $$(patsubst %, delete_%_file/, $$(EXES))
169 | $(patsubst %, delete_%_dir, $(ALL_OBJ_DIRS) ): $$(patsubst delete_%_dir, delete_%*.o_file/, $$(@))
170 | $(patsubst %, delete_%_dir, $(ALL_DEPS_DIRS)): $$(patsubst delete_%_dir, delete_%*.d_file/, $$(@))
171 | 
172 | delete_%_file/:
173 | 	@$(eval DELFILE = $(@:delete_%_file/=%))
174 | 	@for f in $(DELFILE); do if [ $$f ]; then echo rm -f $$f; fi; done;
175 | 	@for f in $(DELFILE); do if [ $$f ]; then      rm -f $$f; fi; done;
176 | 
177 | $(DIRS:%=delete_%_dir):
178 | 	@$(eval DELDIR = $(@:delete_%_dir=%))
179 | 	@if [ -d "$(DELDIR)" ]; then echo rmdir "$(DELDIR)"; fi
180 | 	@if [ -e "$(DELDIR)" ]; then      rmdir --ignore-fail-on-non-empty "$$(readlink --canonicalize "$(DELDIR)")"; fi
181 | 
182 | endif
183 | 


--------------------------------------------------------------------------------
/src/algo/gpu_algos.cpp:
--------------------------------------------------------------------------------
  1 | #include "gpu_algos.hpp"
  2 | 
  3 | #include <impl/cpu_impl.hpp>
  4 | #include <impl/gpu_impl.hpp>
  5 | #include <util/logging.hpp>
  6 | 
  7 | #include <cuda_runtime.h>
  8 | #include <chrono>
  9 | 
 10 | static const bool use_cpu_find_entering = false;
 11 | static const bool use_cpu_find_leaving = false;
 12 | 
 13 | namespace simplex{
 14 | 
 15 | boost::variant<
 16 | 	Assignments,
 17 | 	TableauErrors
 18 | > gpu_cpu_algo_from_paper(const Problem& problem) {
 19 | 	using cpu::create_tableau;
 20 | 	using gpu::update_leaving_row;
 21 | 	using gpu::update_rest_of_basis;
 22 | 	using gpu::update_entering_column;
 23 | 
 24 | 	const auto indent = dout(DL::INFO).indentWithTitle("Algorithm from the Paper (GPU)");
 25 | 
 26 | 	auto start_create = std::chrono::system_clock::now();;
 27 | 	auto cpu_tableau = create_tableau(problem);
 28 | 	auto end_create = std::chrono::system_clock::now();;
 29 | 	double total_time_create = ((std::chrono::duration<double>)(end_create - start_create)).count();
 30 | 
 31 | 	auto gpu_tableau = Tableau<double>(NULL, cpu_tableau.height(), cpu_tableau.width());
 32 | 
 33 | 	auto cpu_first_row_memory_owner = std::vector<double>((std::size_t)cpu_tableau.width());
 34 | 	auto cpu_first_row = util::PointerAndSize<double>(cpu_first_row_memory_owner);
 35 | 	auto cpu_tv_and_centering = cpu::ThetaValuesAndEnteringColumn<double>(cpu_tableau.height());
 36 | 
 37 | 	auto copy_tableau_gpu_to_cpu = [&]() { cudaMemcpy(cpu_tableau.data(), gpu_tableau.data(), static_cast<std::size_t>(gpu_tableau.data_size()), cudaMemcpyDeviceToHost); };
 38 | 	auto copy_tableau_cpu_to_gpu = [&]() { cudaMemcpy(gpu_tableau.data(), cpu_tableau.data(), static_cast<std::size_t>(cpu_tableau.data_size()), cudaMemcpyHostToDevice); };
 39 | 
 40 | 	cudaMalloc(&gpu_tableau.data(), static_cast<std::size_t>(cpu_tableau.data_size()));
 41 | 
 42 | 	copy_tableau_cpu_to_gpu();
 43 | 
 44 | 
 45 | 	int iteration_num = 1;
 46 | 
 47 | 	double total_time = 0;
 48 | 	double total_time_k2 = 0;
 49 | 	double total_time_k3 = 0;
 50 | 	double total_time_k4 = 0;
 51 | 	auto start_time = std::chrono::system_clock::now();;
 52 | 	while (true) {
 53 | 
 54 | 		const auto indent = dout(DL::INFO).indentWithTitle([&](auto&& s){ s << "Iteration " << iteration_num; });
 55 | 
 56 | 		if (dout(DL::DBG1).enabled()) {
 57 | 			copy_tableau_gpu_to_cpu();
 58 | 			dout(DL::DBG1) << "tableau:\n" << cpu_tableau << '\n';
 59 | 		}
 60 | 
 61 | 
 62 | 		boost::optional<VariableIndex> entering_var;
 63 | 		if (use_cpu_find_entering) {
 64 | 			using cpu::find_entering_variable;
 65 | 			cudaMemcpy(cpu_first_row.data(), gpu_tableau.data(), (std::size_t)cpu_first_row.data_size(), cudaMemcpyDeviceToHost);
 66 | 			entering_var = find_entering_variable(cpu_first_row);
 67 | 		} else {
 68 | 			const auto indent = dout(DL::DBG1).indentWithTitle("find_entering_variable");
 69 | 
 70 | 			using gpu::find_entering_variable;
 71 | 			util::PointerAndSize<double> gpu_first_row(gpu_tableau.data(), gpu_tableau.width());
 72 | 			const auto entering_var_raw = find_entering_variable(gpu_first_row);
 73 | 
 74 | 			if (entering_var_raw >= 0) {
 75 | 				entering_var = util::make_id<VariableIndex>((VariableIndex::IDType)entering_var_raw);
 76 | 			}
 77 | 		}
 78 | 
 79 | 		if (!entering_var) {
 80 | 			dout(DL::INFO) << "Solution reached!\n";
 81 | 			break;
 82 | 		}
 83 | 		
 84 | 		// k1
 85 | 		auto indent_gtvaec = dout(DL::DBG1).indentWithTitle("get_theta_values_and_entering_column");
 86 | 
 87 | 		using gpu::get_theta_values_and_entering_column;
 88 | 		auto gpu_tv_and_centering = get_theta_values_and_entering_column(gpu_tableau, *entering_var);
 89 | 
 90 | 		indent_gtvaec.endIndent();
 91 | 
 92 | 		boost::optional<VariableIndex> leaving_var;
 93 | 		if (use_cpu_find_leaving) {
 94 | 			cudaMemcpy(cpu_tv_and_centering.entering_column.data(), gpu_tv_and_centering.entering_column.data(), (std::size_t)gpu_tv_and_centering.entering_column.data_size(), cudaMemcpyDeviceToHost);
 95 | 			cudaMemcpy(cpu_tv_and_centering.theta_values.data(), gpu_tv_and_centering.theta_values.data(), (std::size_t)gpu_tv_and_centering.theta_values.data_size(), cudaMemcpyDeviceToHost);
 96 | 			leaving_var = find_leaving_variable(cpu_tv_and_centering);
 97 | 		} else {
 98 | 			const auto indent = dout(DL::DBG1).indentWithTitle("find_leaving_variable");
 99 | 			const auto leaving_var_raw = find_leaving_variable(gpu_tv_and_centering);
100 | 			if (leaving_var_raw >= 0) {
101 | 				leaving_var = util::make_id<VariableIndex>((VariableIndex::IDType)leaving_var_raw);
102 | 			}
103 | 		}
104 | 
105 | 		if (!leaving_var) {
106 | 			dout(DL::INFO) << "Problem is unbounded!\n";
107 | 			break;
108 | 		}
109 | 
110 | 		VariablePair entering_and_leaving = {
111 | 			*entering_var,
112 | 			*leaving_var,
113 | 		};
114 | 
115 | 		auto start_k2 = std::chrono::system_clock::now();
116 | 		{const auto indent = dout(DL::DBG1).indentWithTitle("update_leaving_row");
117 | 		update_leaving_row( // k2
118 | 			gpu_tableau,
119 | 			gpu_tv_and_centering.entering_column,
120 | 			entering_and_leaving
121 | 		);
122 | 			if (dout(DL::DBG2).enabled()) {
123 | 				copy_tableau_gpu_to_cpu();
124 | 				dout(DL::DBG2) << "tableau after:\n" << cpu_tableau << '\n';
125 | 			}
126 | 		}
127 | 		auto end_k2 = std::chrono::system_clock::now();
128 | 
129 | 		auto start_k3 = std::chrono::system_clock::now();
130 | 		{const auto indent = dout(DL::DBG1).indentWithTitle("update_rest_of_basis");
131 | 		update_rest_of_basis( // k3
132 | 			gpu_tableau,
133 | 			gpu_tv_and_centering.entering_column,
134 | 			entering_and_leaving.leaving
135 | 		);
136 | 			if (dout(DL::DBG2).enabled()) {
137 | 				copy_tableau_gpu_to_cpu();
138 | 				dout(DL::DBG2) << "tableau after:\n" << cpu_tableau << '\n';
139 | 			}
140 | 		}
141 | 		auto end_k3 = std::chrono::system_clock::now();
142 | 
143 | 
144 | 		auto start_k4 = std::chrono::system_clock::now();
145 | 		{const auto indent = dout(DL::DBG1).indentWithTitle("update_entering_column");
146 | 		update_entering_column( //k4
147 | 			gpu_tableau,
148 | 			gpu_tv_and_centering.entering_column,
149 | 			entering_and_leaving
150 | 		);
151 | 			if (dout(DL::DBG2).enabled()) {
152 | 				copy_tableau_gpu_to_cpu();
153 | 				dout(DL::DBG2) << "tableau after:\n" << cpu_tableau << '\n';
154 | 			}
155 | 		}
156 | 		auto end_k4 = std::chrono::system_clock::now();
157 | 
158 | 		cudaFree(gpu_tv_and_centering.theta_values.data());
159 | 		cudaFree(gpu_tv_and_centering.entering_column.data());
160 | 		iteration_num += 1;
161 | 
162 | 		total_time_k2 += ((std::chrono::duration<double>)(end_k2 - start_k2)).count();
163 | 		total_time_k3 += ((std::chrono::duration<double>)(end_k3 - start_k3)).count();
164 | 		total_time_k4 += ((std::chrono::duration<double>)(end_k4 - start_k4)).count();
165 | 
166 | 		if (iteration_num == 10000) break;
167 | 	}
168 | 	auto finish_time = std::chrono::system_clock::now();
169 | 
170 | 	copy_tableau_gpu_to_cpu();
171 | 
172 | 	{const auto indent = dout(DL::INFO).indentWithTitle("Result");
173 | 		dout(DL::INFO) << cpu_tableau << '\n';
174 | 	}
175 | 
176 | 	cudaFree(gpu_tableau.data());
177 | 	delete cpu_tableau.data();
178 | 
179 | 	total_time += ((std::chrono::duration<double>)(finish_time - start_time)).count();
180 | 	double average_time = total_time/(iteration_num-1);
181 | 	// double average_k2 = total_time_k2/(iteration_num-1);
182 | 	std::cout << "total_time: " << total_time <<  "\n";
183 | 	std::cout << "average_time: " << average_time <<  "\n";
184 | 	std::cout << "k2 total time: " << total_time_k2 <<  "\n";
185 | 	std::cout << "k3 total time: " << total_time_k3 <<  "\n";
186 | 	std::cout << "k4 total time: " << total_time_k4 <<  "\n";
187 | 	std::cout << "total_time_create: " << total_time_create <<  "\n";
188 | 
189 | 
190 | 	return Assignments{};
191 | }
192 | 
193 | } // end namespace simplex
194 | 


--------------------------------------------------------------------------------
/src/util/utils.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef UTIL_H
  2 | #define UTIL_H
  3 | 
  4 | #include <algorithm>
  5 | #include <memory>
  6 | #include <sstream>
  7 | #include <string>
  8 | 
  9 | #include <iostream>
 10 | 
 11 | template <typename...> struct all_convertible;
 12 | 
 13 | template <> struct all_convertible<> : std::true_type { };
 14 | 
 15 | template <typename T> struct all_convertible<T> : std::true_type { };
 16 | 
 17 | template <typename T, typename V, typename... Rest> struct all_convertible<T, V, Rest...>
 18 | : std::integral_constant<
 19 | 	bool,
 20 | 	std::is_convertible<V, T>::value && all_convertible<T,Rest...>::value
 21 | > { };
 22 | 
 23 | namespace util {
 24 | 	template<typename T>
 25 | 	void reverse(T& t) {
 26 | 		using std::begin; using std::end;
 27 | 		reverse(begin(t),end(t));
 28 | 	}
 29 | 
 30 | 	template<typename FUNC>
 31 | 	void repeat(int count, const FUNC& f) {
 32 | 		for (int i = 1; i <= count; ++i) {
 33 | 			f();
 34 | 		}
 35 | 	}
 36 | 
 37 | 	template<typename T>
 38 | 	std::shared_ptr<T> make_shared(T&& t) {
 39 | 		return std::make_shared<
 40 | 			typename std::remove_cv<
 41 | 				typename std::remove_reference<T>::type
 42 | 			>::type
 43 | 		>(
 44 | 			std::forward<T>(t)
 45 | 		);
 46 | 	}
 47 | 
 48 | 	template<typename T>
 49 | 	T make_copy(const T& t) {
 50 | 		return T(t);
 51 | 	}
 52 | 
 53 | 	template<typename CONTAINER, typename PRED>
 54 | 	void remove_if_assoc(CONTAINER& c, PRED&& p) {
 55 | 		using std::begin; using std::end;
 56 | 		for(auto it = begin(c); it != end(c); ) {
 57 | 			if (p(*it)) {
 58 | 				it = c.erase(it);
 59 | 			} else {
 60 | 				++it;
 61 | 			}
 62 | 		}
 63 | 	}
 64 | 
 65 | 	template<typename CONTAINER>
 66 | 	bool empty(CONTAINER&& c) {
 67 | 		using std::begin;
 68 | 		using std::end;
 69 | 		return begin(c) == end(c);
 70 | 	}
 71 | }
 72 | 
 73 | /*******
 74 |  * Begin definition of ComparesWithTag
 75 |  *******/
 76 | 
 77 | template<typename T, typename U>
 78 | class ComparesWithTag {
 79 | 	const T& thing;
 80 | 	U identifier;
 81 | 
 82 | public:
 83 | 	ComparesWithTag(const T& thing, U identifier)
 84 | 		: thing(thing)
 85 | 		, identifier(identifier)
 86 | 	{ }
 87 | 	ComparesWithTag(const ComparesWithTag&) = default;
 88 | 	ComparesWithTag& operator=(const ComparesWithTag&) = delete;
 89 | 	ComparesWithTag& operator=(ComparesWithTag&&) = default;
 90 | 
 91 | 	operator std::tuple<T,U>() const {
 92 | 		return {thing,identifier};
 93 | 	}
 94 | 
 95 | 	template<typename THEIR_T, typename THEIR_U>
 96 | 	bool operator<(const ComparesWithTag<THEIR_T,THEIR_U> rhs) const {
 97 | 		return thing < rhs.thing;
 98 | 	}
 99 | 
100 | 	const T& value() const { return thing; }
101 | 	U id() const { return identifier; }
102 | };
103 | 
104 | 
105 | /**
106 |  * Allows you to tag some data along when you call std::max or something.
107 |  * Defines operator< using the first argumen's operator<
108 |  *
109 |  * Example:
110 |  *    enum class MyEnum {
111 |  *        A,B,
112 |  *    };
113 |  *
114 |  *    auto result = std::max(
115 |  *        compare_with_tag(getA(),MyEnum::A),
116 |  *        compare_with_tag(getB(),MyEnum::B)
117 |  *    );
118 |  *
119 |  *    if (result.id() == MyEnum::A) {
120 |  *        std::cout << "A was smaller, A = " << result << '\n';
121 |  *    } else if (result.id() == MyEnum::B) {
122 |  *        std::cout << "B was smaller, B = " << result << '\n';
123 |  *    }
124 |  */
125 | template<typename T, typename U>
126 | ComparesWithTag<T,U> compare_with_tag(const T& thing, U id) {
127 | 	return ComparesWithTag<T,U>(thing,id);
128 | }
129 | 
130 | template<typename T, typename V = void>
131 | using EnableIfEnum = typename std::enable_if<std::is_enum<T>::value,V>;
132 | 
133 | template<typename T, typename V = void>
134 | using EnableIfIntegral = typename std::enable_if<std::is_integral<T>::value,V>;
135 | 
136 | template<typename CAST_TO>
137 | struct StaticCaster {
138 | 	template<typename SRC>
139 | 	CAST_TO operator()(SRC src) const {
140 | 		return static_cast<CAST_TO>(src);
141 | 	}
142 | };
143 | 
144 | namespace util {
145 | 
146 | template<typename T>
147 | std::string stringify_through_stream(const T& t) {
148 | 	std::ostringstream stream;
149 | 	stream << t;
150 | 	return stream.str();
151 | }
152 | 
153 | template<typename RETVAL_TYPE, typename ITER_TYPE>
154 | class DerefAndIncrementer {
155 | 	ITER_TYPE iter;
156 | 	size_t i;
157 | public:
158 | 	DerefAndIncrementer(ITER_TYPE beg) : iter(beg), i(0) { }
159 | 	template<typename ARG>
160 | 	RETVAL_TYPE operator()(const ARG&) {
161 | 		RETVAL_TYPE result = *iter;
162 | 		std::cout << result << " - " << i << '\n';
163 | 		++iter;
164 | 		++i;
165 | 		return result;
166 | 	}
167 | };
168 | 
169 | /**
170 |  * Retuns a lambda stlye object that will return the value of
171 |  * *iter the first time it is called, then *std::next(iter), etc.
172 |  */
173 | template<typename RETVAL_TYPE, typename ITER_TYPE>
174 | DerefAndIncrementer<RETVAL_TYPE,ITER_TYPE> make_deref_and_incrementer(const ITER_TYPE& iter) {
175 | 	return DerefAndIncrementer<RETVAL_TYPE,ITER_TYPE>(iter);
176 | }
177 | 
178 | template<class InputIt, class UnaryPredicate>
179 | std::pair<InputIt,size_t> find_by_index(InputIt first, InputIt last, UnaryPredicate p) {
180 | 	size_t index = 0;
181 | 	for (; first != last; ++first, ++index) {
182 | 		if (p(index)) {
183 | 			return { first, index };
184 | 		}
185 | 	}
186 | 	return { last, index };
187 | }
188 | 
189 | template<class InputIt, class BinaryPredicate>
190 | std::pair<InputIt,size_t> find_with_index(InputIt first, InputIt last, BinaryPredicate p) {
191 | 	size_t index = 0;
192 | 	for (; first != last; ++first, ++index) {
193 | 		if (p(*first,index)) {
194 | 			return { first, index };
195 | 		}
196 | 	}
197 | 	return { last, index };
198 | }
199 | 
200 | template<class ForwardIt, class UnaryPredicate>
201 | ForwardIt remove_by_index(ForwardIt first, ForwardIt last, UnaryPredicate p) {
202 | 	size_t index = 0;
203 | 	std::tie(first, index) = find_by_index(first, last, p);
204 | 	if (first != last) {
205 | 		for(ForwardIt i = first; i != last; ++i, ++index) {
206 | 			if (!p(index)) {
207 | 				*first = std::move(*i);
208 | 				++first;
209 | 			}
210 | 		}
211 | 	}
212 | 	return first;
213 | }
214 | 
215 | namespace detail {
216 | 	struct printer {
217 | 	template<typename STREAM, typename T>
218 | 		void operator()(STREAM& os, const T& t) const {
219 | 			os << t;
220 | 		}
221 | 	};
222 | }
223 | 
224 | template<typename CONTAINER, typename OSTREAM, typename FUNC = ::util::detail::printer>
225 | void print_container(
226 | 	OSTREAM&& os,
227 | 	const CONTAINER& c,
228 | 	const std::string& sep,
229 | 	const std::string& prefix_str,
230 | 	const std::string& suffix_str,
231 | 	FUNC func = FUNC{}
232 | ) {
233 | 	using std::begin; using std::end;
234 | 	auto beg = begin(c);
235 | 	auto en = end(c);
236 | 
237 | 	os << prefix_str;
238 | 	if (beg != en) {
239 | 		func(os,*beg);
240 | 		std::for_each(std::next(beg), en, [&](const decltype(*std::begin(c))& v){
241 | 			os << sep;
242 | 			func(os,v);
243 | 		});
244 | 	}
245 | 	os << suffix_str;
246 | }
247 | 
248 | template<typename CONTAINER, typename OSTREAM, typename FUNC = ::util::detail::printer>
249 | void print_container(
250 | 	OSTREAM&& os,
251 | 	const CONTAINER& c,
252 | 	FUNC func = FUNC{}
253 | ) {
254 | 	print_container(os, c, ", ", "{ ", " }", func);
255 | }
256 | 
257 | template<typename CONTAINER, typename OSTREAM, typename KEY_FUNC = ::util::detail::printer, typename VALUE_FUNC = ::util::detail::printer>
258 | void print_assoc_container(
259 | 	OSTREAM&& os,
260 | 	const CONTAINER& c,
261 | 	const std::string& sep,
262 | 	const std::string& prefix_str,
263 | 	const std::string& suffix_str,
264 | 	KEY_FUNC func_value = KEY_FUNC{},
265 | 	VALUE_FUNC func_key = VALUE_FUNC{}
266 | ) {
267 | 	using std::begin; using std::end;
268 | 	auto beg = begin(c);
269 | 	auto en = end(c);
270 | 
271 | 	os << prefix_str;
272 | 	if (beg != en) {
273 | 		os << prefix_str;
274 | 		func_key(os,beg->first);
275 | 		os << " -> ";
276 | 		func_value(os,beg->second);
277 | 		os << suffix_str;
278 | 		std::for_each(std::next(beg), en, [&](const decltype(*std::begin(c))& v){
279 | 			os << sep;
280 | 			os << prefix_str;
281 | 			func_key(os,v.first);
282 | 			os << " -> ";
283 | 			func_value(os,v.second);
284 | 			os << suffix_str;
285 | 		});
286 | 	}
287 | 	os << suffix_str;
288 | }
289 | 
290 | template<typename CONTAINER, typename OSTREAM, typename KEY_FUNC = ::util::detail::printer, typename VALUE_FUNC = ::util::detail::printer>
291 | void print_assoc_container(
292 | 	OSTREAM&& os,
293 | 	const CONTAINER& c,
294 | 	KEY_FUNC func_value = KEY_FUNC{},
295 | 	VALUE_FUNC func_key = VALUE_FUNC{}
296 | ) {
297 | 	print_assoc_container(os, c, ", ", "{ ", " }", func_value, func_key);
298 | }
299 | 
300 | } // end namespace util
301 | 
302 | #endif /* UTIL_H */
303 | 


--------------------------------------------------------------------------------
/src/impl/cpu_impl.cpp:
--------------------------------------------------------------------------------
  1 | #include "cpu_impl.hpp"
  2 | 
  3 | #include <util/logging.hpp>
  4 | 
  5 | #include <exception>
  6 | 
  7 | #include <Eigen/Core>
  8 | #include <Eigen/LU>
  9 | 
 10 | namespace simplex {
 11 | namespace cpu {
 12 | 
 13 | Tableau<double> create_tableau(const Problem& problem_stmt) {
 14 | 	const auto indent = dout(DL::DBG1).indentWithTitle("create_tableau");
 15 | 
 16 | 	const auto num_constraints = problem_stmt.num_constraints();
 17 | 	const auto num_variables = problem_stmt.num_variables();
 18 | 
 19 | 	dout(DL::DBG1) << "num_variables = " << num_variables << "\nnum_constraints = " << num_constraints << '\n';
 20 | 
 21 | 	Eigen::MatrixXd constraint_matrix(num_constraints + 1, num_variables + 1);
 22 | 	constraint_matrix.setZero();
 23 | 
 24 | 	{int constr_count = 0;
 25 | 	for (const auto& constr : problem_stmt.constraints()) {
 26 | 		auto current_cm_row = constraint_matrix.row(constr_count + 1);
 27 | 
 28 | 		current_cm_row(0) = constr.m_rhs;
 29 | 		for (const auto& varid_and_val : constr.m_coeffs) {
 30 | 			current_cm_row(varid_and_val.first.getValue() + 1) = varid_and_val.second;
 31 | 		}
 32 | 
 33 | 		constr_count += 1;
 34 | 	}}
 35 | 
 36 | 	{auto objective_coeffs = constraint_matrix.row(0);
 37 | 	for (const auto& var_and_info : problem_stmt.variables()) {
 38 | 		objective_coeffs(var_and_info.first.getValue() + 1) = var_and_info.second.m_coeff;
 39 | 	}}
 40 | 
 41 | 	dout(DL::DBG3) << "constraint matrix\n" << constraint_matrix << '\n';
 42 | 
 43 | 	const auto& constraint_consts = constraint_matrix.leftCols<1>().segment(1, num_constraints);
 44 | 	const auto& basis = Eigen::MatrixXd::Identity(num_constraints,num_constraints);
 45 | 	const auto& basic_coeff = Eigen::RowVectorXd::Zero(num_constraints);
 46 | 	const auto& nonbasics = constraint_matrix.bottomRightCorner(num_constraints, num_variables);
 47 | 	const auto& nonbasics_coeff = constraint_matrix.topRows<1>().segment(1, num_variables);
 48 | 
 49 | 	const auto& inv_basis = basis.inverse();
 50 | 	const auto& inv_basis_times_nonbasis = inv_basis*nonbasics;
 51 | 	const auto& inv_basis_times_constraint_coeffs = inv_basis*constraint_consts;
 52 | 
 53 | 	const auto& upper_right = basic_coeff*inv_basis_times_nonbasis - nonbasics_coeff;
 54 | 	const auto& lower_right = inv_basis_times_nonbasis;
 55 | 
 56 | 	const auto& upper_left = basic_coeff*inv_basis_times_constraint_coeffs;
 57 | 	const auto& lower_left = inv_basis_times_constraint_coeffs;
 58 | 
 59 | 	(void)upper_right; // dout(DL::DBG3) << "upper_right:\n" << upper_right << '\n';
 60 | 	(void)lower_right; // dout(DL::DBG3) << "lower_right:\n" << lower_right << '\n';
 61 | 
 62 | 	(void)upper_left; // dout(DL::DBG3) << "upper_left:\n" << upper_left << '\n';
 63 | 	(void)lower_left; // dout(DL::DBG3) << "lower_left:\n" << lower_left << '\n';
 64 | 
 65 | 	// Eigen::MatrixXd tableau_data(num_constraints+1, num_variables+1); tableau_data <<
 66 | 	// 	upper_left, upper_right, lower_left, lower_right
 67 | 	// ;
 68 | 
 69 | 	constraint_matrix.row(0) *= -1;
 70 | 	constraint_matrix(0,0) = 0; // upper_left(0,0); // always zero
 71 | 	const auto& tableau_data = constraint_matrix;
 72 | 
 73 | 	dout(DL::DBG3) << "tableau_data:\n" << tableau_data << '\n';
 74 | 
 75 | 	Tableau<double> result (
 76 | 		new double[static_cast<std::size_t>(tableau_data.rows() * tableau_data.cols())],
 77 | 		tableau_data.rows(),
 78 | 		tableau_data.cols()
 79 | 	);
 80 | 
 81 | 	for (std::ptrdiff_t irow = 0; irow < tableau_data.rows(); ++irow) {
 82 | 		for (std::ptrdiff_t icol = 0; icol < tableau_data.cols(); ++icol) {
 83 | 			result.at(irow, icol) = tableau_data(irow, icol);
 84 | 		}
 85 | 	}
 86 | 
 87 | 	return result;
 88 | }
 89 | 
 90 | boost::optional<VariableIndex> find_entering_variable(const util::PointerAndSize<double>& first_row) {
 91 | 	const auto indent = dout(DL::DBG1).indentWithTitle("find_entering_variable");
 92 | 	dout(DL::DBG2) << "first row given: ";
 93 | 	util::print_container(dout(DL::DBG2), first_row);
 94 | 	dout(DL::DBG2) << '\n';
 95 | 
 96 | 	double lowest_value = 0;
 97 | 	boost::optional<VariableIndex> result;
 98 | 
 99 | 	for (int icol = 1; icol < first_row.size(); ++icol) {
100 | 		const auto& val = first_row.at(icol);
101 | 		if (val < lowest_value) {
102 | 			lowest_value = val;
103 | 			result = util::make_id<VariableIndex>(icol);
104 | 		}
105 | 	}
106 | 
107 | 	if (result) {
108 | 		dout(DL::DBG1) << "found entering variable: " << *result << '\n';
109 | 	} else {
110 | 		dout(DL::DBG1) << "did not find a entering variable\n";
111 | 	}
112 | 
113 | 	return result;
114 | }
115 | 
116 | ThetaValuesAndEnteringColumn<double> get_theta_values_and_entering_column(const Tableau<double>& tab, VariableIndex entering) {
117 | 	const auto indent = dout(DL::DBG1).indentWithTitle("get_theta_values_and_entering_column");
118 | 	ThetaValuesAndEnteringColumn<double> result (
119 | 		tab.height()
120 | 	);
121 | 
122 | 	for (int irow = 0; irow < tab.height(); ++irow) {
123 | 		const auto& val_at_entering = tab.at(irow, entering);
124 | 		result.entering_column.at((std::size_t)irow) = val_at_entering;
125 | 		result.theta_values.at((std::size_t)irow) = tab.at(irow, 0)/val_at_entering;
126 | 	}
127 | 
128 | 	dout(DL::DBG1) << "theta_values computed: ";
129 | 	util::print_container(dout(DL::DBG1), result.theta_values);
130 | 	dout(DL::DBG1) << "\nentering_column copied: ";
131 | 	util::print_container(dout(DL::DBG1), result.entering_column);
132 | 	dout(DL::DBG1) << '\n';
133 | 
134 | 	return result;
135 | }
136 | 
137 | boost::optional<VariableIndex> find_leaving_variable(const ThetaValuesAndEnteringColumn<double>& tvals_and_centering) {
138 | 	const auto indent = dout(DL::DBG1).indentWithTitle("find_leaving_variable");
139 | 	dout(DL::DBG2) << "theta_values given: ";
140 | 	util::print_container(dout(DL::DBG2), tvals_and_centering.theta_values);
141 | 	dout(DL::DBG2) << "\nentering_column given: ";
142 | 	util::print_container(dout(DL::DBG2), tvals_and_centering.entering_column);
143 | 	dout(DL::DBG2) << '\n';
144 | 
145 | 	auto lowest_theta_value = std::numeric_limits<double>::max();
146 | 	boost::optional<VariableIndex> result;
147 | 
148 | 	for (int irow = 1; irow < (int)tvals_and_centering.theta_values.size(); ++irow) {
149 | 		const auto& theta_val = tvals_and_centering.theta_values.at((std::size_t)irow);
150 | 		const auto& tab_val = tvals_and_centering.entering_column.at((std::size_t)irow);
151 | 		if (tab_val > 0 && (!result || theta_val < lowest_theta_value)) {
152 | 			lowest_theta_value = theta_val;
153 | 			result = util::make_id<VariableIndex>(irow);
154 | 		}
155 | 	}
156 | 
157 | 	if (result) {
158 | 		dout(DL::DBG1) << "found leaving variable: " << *result << '\n';
159 | 	} else {
160 | 		dout(DL::DBG1) << "did not find a leaving variable\n";
161 | 	}
162 | 
163 | 	return result;
164 | }
165 | 
166 | Tableau<double> update_leaving_row(Tableau<double>&& tab, const std::vector<double>& entering_column, VariablePair leaving_and_entering) {
167 | 
168 | 	const auto indent = dout(DL::DBG1).indentWithTitle("update_leaving_row");
169 | 
170 | 	auto denom = entering_column.at((std::size_t)leaving_and_entering.leaving.getValue());
171 | 	// dout(DL::LINDA) << "index: " << (std::size_t)leaving_and_entering.leaving.getValue() << '\n';
172 | 	// dout(DL::LINDA) << "denom: " << denom << '\n';
173 | 
174 | 	for (int icol = 0; icol < tab.width(); ++icol) {
175 | 		tab.at(leaving_and_entering.leaving, icol) /= denom;
176 | 	}
177 | 
178 | 	dout(DL::DBG2) << "tableau after:\n" << tab << '\n';
179 | 
180 | 	return tab;
181 | }
182 | 
183 | Tableau<double> update_rest_of_basis(Tableau<double>&& tab, const std::vector<double>& entering_column, VariableIndex leaving) {
184 | 	const auto indent = dout(DL::DBG1).indentWithTitle("update_rest_of_basis");
185 | 
186 | 	for (int irow = 0; irow < tab.height(); ++irow) {
187 | 		if (irow == leaving.getValue()) { continue; }
188 | 		const auto& entering_col_val = entering_column.at((std::size_t)irow);
189 | 
190 | 		for (int icol = 0; icol < tab.width(); ++icol) {
191 | 			// dout(DL::LINDA) << "entering_col_val: " << entering_col_val << " tab.at(leaving, icol): " << tab.at(leaving, icol) << " leaving: " << leaving << " icol: " << icol << "\n";
192 | 			tab.at(irow, icol) -= tab.at(leaving, icol) * entering_col_val;
193 | 		}
194 | 	}
195 | 
196 | 	dout(DL::DBG2) << "tableau after:\n" << tab << '\n';
197 | 
198 | 	return tab;
199 | }
200 | 
201 | Tableau<double> update_entering_column(Tableau<double>&& tab, const std::vector<double>& entering_column, VariablePair leaving_and_entering) {
202 | 	const auto indent = dout(DL::DBG1).indentWithTitle("update_entering_column");
203 | 
204 | 	auto denom = entering_column.at((std::size_t)leaving_and_entering.leaving.getValue());
205 | 
206 | 	// printf("index: %d denom: %f\n", leaving_and_entering.leaving.getValue(), denom);
207 | 
208 | 	for (int irow = 0; irow < tab.height(); ++irow) {
209 | 		if (irow == leaving_and_entering.leaving.getValue()) {
210 | 			tab.at(irow, leaving_and_entering.entering) = 1/denom;
211 | 		} else {
212 | 			tab.at(irow, leaving_and_entering.entering) = - entering_column.at((std::size_t)irow)/denom;
213 | 		}
214 | 	}
215 | 
216 | 	dout(DL::DBG2) << "tableau after:\n" << tab << '\n';
217 | 
218 | 	return tab;
219 | }
220 | 
221 | } // end namespace simplex
222 | } // end namespace cpu
223 | 


--------------------------------------------------------------------------------
/src/util/logging.hpp:
--------------------------------------------------------------------------------
  1 | 
  2 | #ifndef UTIL__LOGGING_H
  3 | #define UTIL__LOGGING_H
  4 | 
  5 | #include <util/utils.hpp>
  6 | 
  7 | #include <bitset>
  8 | #include <cstdint>
  9 | #include <iostream>
 10 | #include <sstream>
 11 | #include <string>
 12 | #include <vector>
 13 | 
 14 | #include <boost/iostreams/filtering_stream.hpp>
 15 | 
 16 | class IndentingLeveledDebugPrinter;
 17 | 
 18 | namespace DebugLevel {
 19 | 	/**
 20 | 	 * The Enum of the levels usable with IndentingLeveledDebugPrinter
 21 | 	 * If adding a level make sure to update the various functions in this namespace.
 22 | 	 */
 23 | 	enum Level : uint {
 24 | 		LEVEL_START = 0,
 25 | 		INFO = LEVEL_START,  // probably always going to have this on?
 26 | 		WARN,  // same as ^ ?
 27 | 		ERROR, // always on
 28 | 
 29 | 		DBG1, // debug level 1
 30 | 		DBG2, // debug level 2
 31 | 		DBG3, // debug level 3
 32 | 		DBG4, // lowest level debug
 33 | 		LINDA, // best level debug
 34 | 
 35 | 		DATA_READ1, // reading of data
 36 | 
 37 | 		LEVEL_COUNT, // please make sure this is at the end
 38 | 	};
 39 | 
 40 | 	/**
 41 | 	 * Get the default set of print levels that should probably always be enabled
 42 | 	 * Most code assumes these are already on.
 43 | 	 */
 44 | 	std::vector<Level> getDefaultSet();
 45 | 
 46 | 	/**
 47 | 	 * Get all the levels that you might ever want if debugging was your goal
 48 | 	 */
 49 | 	std::vector<Level> getStandardDebug();
 50 | 
 51 | 	/**
 52 | 	 * If you feel like enabling a particular level, then
 53 | 	 * call this function to get all the levels that probably
 54 | 	 * should also be enabled
 55 | 	 */
 56 | 	std::vector<Level> getAllShouldBeEnabled(Level l);
 57 | 
 58 | 	std::pair<Level,bool> getFromString(std::string str);
 59 | 	std::string getAsString(Level l);
 60 | 
 61 | 	template<typename Func>
 62 | 	void forEachLevel(Func&& f) {
 63 | 		for (uint i = Level::LEVEL_START; i < Level::LEVEL_COUNT; ++i) {
 64 | 			f(Level(i));
 65 | 		}
 66 | 	}
 67 | 
 68 | }
 69 | 
 70 | using DL = DebugLevel::Level;
 71 | 
 72 | /**
 73 |  * This class supplies REDIRECT_TYPE operator()(LEVEL_TYPE) and
 74 |  * methods for manipulating the enable/disable state of each level
 75 |  *
 76 |  * Classes that use this are expected to inherit from this class,
 77 |  * so that the level manipulation & operator() usage is seamless.
 78 |  * It is not necessary, however.
 79 |  *
 80 |  * Template Arguments:
 81 |  * STREAM_GET_TYPE - something that provides operator()(LevelRedirecter*)
 82 |  *     which converts it's argument to something that can be passed
 83 |  *     to the constructor of REDIRECT_TYPE
 84 |  * REDIRECT_TYPE - the return value of the operator()(LEVEL_TYPE). Must
 85 |  *     be constructable from the return value of STREAM_GET_TYPE()(LevelRedirecter*)
 86 |  * LEVEL_TYPE - the type that should be passed to operator()(LEVEL_TYPE)
 87 |  * NUM_LEVELS - the total number & one plus the maximum of the levels that will be usable
 88 |  *     The enable/disable functions will throw exceptions if called with something
 89 |  *     equal or greater to this.
 90 |  */
 91 | template<
 92 | 	typename STREAM_GET_TYPE,
 93 | 	typename REDIRECT_TYPE,
 94 | 	typename LEVEL_TYPE,
 95 | 	size_t NUM_LEVELS
 96 | >
 97 | class LevelRedirecter {
 98 | private:
 99 | 	std::bitset<NUM_LEVELS> enabled_levels;
100 | 
101 | public:
102 | 	LevelRedirecter()
103 | 		: enabled_levels()
104 | 	{ }
105 | 
106 | 	virtual ~LevelRedirecter() = default;
107 | 
108 | 	LevelRedirecter(const LevelRedirecter&) = delete;
109 | 	LevelRedirecter& operator=(const LevelRedirecter&) = delete;
110 | 
111 | 	LevelRedirecter(LevelRedirecter&&) = default;
112 | 	LevelRedirecter& operator=(LevelRedirecter&&) = default;
113 | 
114 | 	REDIRECT_TYPE operator()(const LEVEL_TYPE& level) {
115 | 		if (enabled_levels.test(level)) {
116 | 			return REDIRECT_TYPE(STREAM_GET_TYPE()(this));
117 | 		} else {
118 | 			return REDIRECT_TYPE(nullptr);
119 | 		}
120 | 	}
121 | 
122 | 	template<typename T>
123 | 	void enable_level(const T& level) {
124 | 		set_enable_for_level(level,true);
125 | 	}
126 | 
127 | 	template<typename T>
128 | 	void disable_level(const T& level) {
129 | 		set_enable_for_level(level,false);
130 | 	}
131 | 
132 | 	template<typename LOCAL_LEVEL_TYPE>
133 | 	void set_enable_for_level(
134 | 		const LOCAL_LEVEL_TYPE& level,
135 | 		bool enable,
136 | 		typename EnableIfEnum<LOCAL_LEVEL_TYPE>::type** = 0,
137 | 		typename std::enable_if<std::is_same<LOCAL_LEVEL_TYPE,LEVEL_TYPE>::value>::type* = 0
138 | 	) {
139 | 		enabled_levels.set(
140 | 			static_cast<std::underlying_type_t<LOCAL_LEVEL_TYPE>>(level),
141 | 			enable
142 | 		);
143 | 	}
144 | 
145 | 	template<typename LOCAL_LEVEL_TYPE>
146 | 	void set_enable_for_level(
147 | 		const LOCAL_LEVEL_TYPE& level,
148 | 		bool enable,
149 | 		typename EnableIfIntegral<LOCAL_LEVEL_TYPE>::type* = 0
150 | 	) {
151 | 		enabled_levels.set(
152 | 			level,
153 | 			enable
154 | 		);
155 | 	}
156 | };
157 | 
158 | /**
159 |  * A little helper class that is returned when an indent is done
160 |  * It will either unindent when its destructor is called, or endIndent() is called
161 |  */
162 | class IndentLevel {
163 | 	friend class IndentingLeveledDebugPrinter;
164 | 	friend class LevelStream;
165 | 	IndentingLeveledDebugPrinter* src;
166 | 	bool ended;
167 | 	IndentLevel(IndentingLeveledDebugPrinter* src) : src(src), ended(false) { }
168 | public:
169 | 	void endIndent();
170 | 	~IndentLevel();
171 | 
172 | 	/**
173 | 	 * Move Constructor - disable the old one, but otherwise copy everything over
174 | 	 */
175 | 	IndentLevel(IndentLevel&& src_ilevel)
176 | 		: src(std::move(src_ilevel.src))
177 | 		, ended(std::move(src_ilevel.ended))
178 | 	{
179 | 		src_ilevel.ended = true;
180 | 	}
181 | 
182 | 	/// copying would cause problems - who would do the unindent?
183 | 	IndentLevel(const IndentLevel&) = delete;
184 | 
185 | 	/**
186 | 	 * Move Assignment - disable the old one, but otherwise copy everything over
187 | 	 */
188 | 	IndentLevel& operator=(IndentLevel&& rhs) {
189 | 		this->src = std::move(rhs.src);
190 | 		this->ended = std::move(rhs.ended);
191 | 		rhs.ended = true;
192 | 		return *this;
193 | 	}
194 | 
195 | 	/// same problems as copying
196 | 	IndentLevel& operator=(const IndentLevel&) = delete;
197 | };
198 | 
199 | /**
200 |  * A helper class for actually printing. IndentingLeveledDebugPrinter doesn't
201 |  * actually have operator<< defined, so that you have to use operator() to print.
202 |  * (it returns an object of this class)
203 |  */
204 | class LevelStream {
205 | private:
206 | 	friend class IndentingLeveledDebugPrinter;
207 | 
208 | 	IndentingLeveledDebugPrinter* src;
209 | 	std::stringstream underlying_ss;
210 | 
211 | public:
212 | 	LevelStream(IndentingLeveledDebugPrinter* src)
213 | 		: src(src)
214 | 		, underlying_ss()
215 | 	{ }
216 | 
217 | 	LevelStream(const LevelStream&) = default;
218 | 	LevelStream(LevelStream&&) = default;
219 | 
220 | 	~LevelStream();
221 | 
222 | 	LevelStream& operator=(const LevelStream&) = default;
223 | 	LevelStream& operator=(LevelStream&&) = default;
224 | 
225 | 	template<typename T>
226 | 	IndentLevel indentWithTitle(const T& t);
227 | 
228 | 	bool enabled() { return src != nullptr; }
229 | 	void flush();
230 | 
231 | 	template<typename T>
232 | 	LevelStream& push_in(const T& t) {
233 | 		if (enabled()) {
234 | 			underlying_ss << t;
235 | 		}
236 | 		return *this;
237 | 	}
238 | };
239 | 
240 | /**
241 |  * The class that handles most of the output control & formatting - the type of dout
242 |  * It inherits from LevelRedirecter to define operator()(Debug::Level) and the enable/disable
243 |  * controls. It also inherits from a filtering_ostream to allow filtering of the output.
244 |  *
245 |  * To print something, you must do dout(DL::*) << "string", and the same must be done for
246 |  * an indent level.
247 |  *
248 |  * The highest_title_rank controls how many '=' to put around the title of the indent level at
249 |  * the default level. Each inner level will be indented one tab stop, and have one fewer '=' on
250 |  * each side of the title's text - with a minimum of one.
251 |  */
252 | class IndentingLeveledDebugPrinter
253 | 	: private boost::iostreams::filtering_ostream
254 | 	, public LevelRedirecter
255 | 		< StaticCaster<IndentingLeveledDebugPrinter*>
256 | 		, LevelStream
257 | 		, DebugLevel::Level
258 | 		, DebugLevel::LEVEL_COUNT
259 | 	>
260 | {
261 | 	int highest_title_rank;
262 | 	int indent_level;
263 | 
264 | 	bool just_saw_newline;
265 | public:
266 | 
267 | 	IndentingLeveledDebugPrinter(std::ostream& os, int highest_title_rank)
268 | 		: boost::iostreams::filtering_ostream()
269 | 		, LevelRedirecter()
270 | 		, highest_title_rank(highest_title_rank)
271 | 		, indent_level(0)
272 | 		, just_saw_newline(false)
273 | 	{
274 | 		push(os);
275 | 	}
276 | 
277 | 	IndentingLeveledDebugPrinter(const IndentingLeveledDebugPrinter&) = delete;
278 | 	IndentingLeveledDebugPrinter& operator=(const IndentingLeveledDebugPrinter&) = delete;
279 | 
280 | 	void print(std::istream& ss) {
281 | 		while (true) {
282 | 			auto c = ss.get();
283 | 			if (ss.eof()) { break; }
284 | 
285 | 			// if we see a newline, remember it, and output spaces next time.
286 | 			if (c == '\n') {
287 | 				just_saw_newline = true;
288 | 			} else if (just_saw_newline) {
289 | 				util::repeat(getNumSpacesToIndent(),[&](){
290 | 					this->put(' ');
291 | 				});
292 | 				just_saw_newline = false;
293 | 			}
294 | 
295 | 			this->put((char_type)c);
296 | 		}
297 | 		flush(); // ensure each ss is printed immediately
298 | 	}
299 | 
300 | 	int getIndentLevel() {
301 | 		return indent_level;
302 | 	}
303 | 
304 | 	int getNumSpacesToIndent() {
305 | 		return indent_level * 2;
306 | 	}
307 | 
308 | 	int getTitleLevel() {
309 | 		if (indent_level >= highest_title_rank) {
310 | 			return 1;
311 | 		} else {
312 | 			return highest_title_rank-indent_level;
313 | 		}
314 | 	}
315 | 
316 | 	void setHighestTitleRank(int level) { highest_title_rank = level; }
317 | 
318 | private:
319 | 	friend class IndentLevel;
320 | 	friend class LevelStream;
321 | 
322 | 	template<typename FUNC>
323 | 	auto indentWithTitle(const FUNC& f) -> decltype(f(std::stringstream()),IndentLevel(this)) {
324 | 		// the weird return value is so the compiler SFINAE's away this
325 | 		// overload if FUNC is not a lambda style type
326 | 		std::stringstream local_ss;
327 | 
328 | 		util::repeat(getTitleLevel(),[&](){
329 | 			local_ss << '=';
330 | 		});
331 | 		local_ss << ' ';
332 | 
333 | 		f(local_ss);
334 | 
335 | 		local_ss << ' ';
336 | 		util::repeat(getTitleLevel(),[&](){
337 | 			local_ss << '=';
338 | 		});
339 | 		local_ss << '\n';
340 | 
341 | 		print(local_ss);
342 | 		indent_level++;
343 | 		return IndentLevel(this);
344 | 	}
345 | 
346 | 	IndentLevel indentWithTitle(const std::string& title) {
347 | 		return indentWithTitle([&](auto&& s){ s << title; });
348 | 	}
349 | 
350 | 	IndentLevel indentWithTitle(const char*& title) {
351 | 		return indentWithTitle([&](auto&& s){ s << title; });
352 | 	}
353 | 
354 | 	void endIndent() {
355 | 		if (indent_level > 0) {
356 | 			indent_level = indent_level - 1;
357 | 		}
358 | 	}
359 | };
360 | 
361 | extern IndentingLeveledDebugPrinter dout;
362 | 
363 | template<typename T>
364 | LevelStream& operator<<(LevelStream&& lhs, const T& t) {
365 | 	return lhs << t;
366 | }
367 | 
368 | template<typename T>
369 | LevelStream& operator<<(LevelStream& lhs, const T& t) {
370 | 	return lhs.push_in(t);
371 | }
372 | 
373 | // has to be down here because the type of src (IndentingLeveledDebugPrinter*)
374 | // hadn't been defined yet, so it needed be be after it to call it's methods
375 | template<typename T>
376 | IndentLevel LevelStream::indentWithTitle(const T& t) {
377 | 	if (enabled()) {
378 | 		return src->indentWithTitle(t);
379 | 	} else {
380 | 		return IndentLevel(nullptr);
381 | 	}
382 | }
383 | 
384 | namespace util {
385 | 	template<typename EXCEPTION, typename FUNC>
386 | 	[[noreturn]] void print_and_throw(FUNC func, ::DebugLevel::Level level = ::DebugLevel::Level::ERROR) {
387 | 		std::ostringstream os;
388 | 		func(os);
389 | 		dout(level) << '\n' << os.str() << '\n';
390 | 		throw EXCEPTION(os.str());
391 | 	}
392 | }
393 | 
394 | #endif /* UTIL__LOGGING_H */
395 | 


--------------------------------------------------------------------------------
/src/impl/gpu_impl.cu:
--------------------------------------------------------------------------------
  1 | #include "gpu_impl.hpp"
  2 | 
  3 | #include <impl/reduction_kernel.cu>
  4 | 
  5 | #include <cassert>
  6 | #include <cstdio>
  7 | #include <iostream>
  8 | #include <iterator>
  9 | #include <limits>
 10 | 
 11 | #include <thrust/device_vector.h>
 12 | #include <thrust/execution_policy.h>
 13 | #include <thrust/functional.h>
 14 | #include <thrust/iterator/zip_iterator.h>
 15 | #include <thrust/transform_reduce.h>
 16 | 
 17 | __global__ void kernel1(double* SimplexTableau, int width, double* theta, double* columnK, int k);
 18 | __global__ void kernel2(double* SimplexTableau, int width, const double* columnK, int r);
 19 | __global__ void kernel3(double* SimplexTableau, int width, int height, const double* columnK, int r);
 20 | __global__ void kernel4(double* SimplexTableau, int width, const double* columnK, int k, int r);
 21 | 
 22 | namespace {
 23 | 	template<typename T>
 24 | 	struct my_numeric_limits;
 25 | 
 26 | 	template<> struct my_numeric_limits<double> {
 27 | 		__host__ __device__ static double max() { return 1.0/0; }
 28 | 	};
 29 | 
 30 | 	template<> struct my_numeric_limits<float> {
 31 | 		__host__ __device__ static float max() { return 1.0f/0; }
 32 | 	};
 33 | }
 34 | 
 35 | namespace simplex {
 36 | namespace gpu {
 37 | 
 38 | template<typename NUMERIC>
 39 | struct FEVComputation {
 40 | 	typedef ptrdiff_t Index;
 41 | 	typedef thrust::tuple<NUMERIC,Index> Element;
 42 | 
 43 | 	struct Direct {
 44 | 		__host__ __device__
 45 | 		static Element identity() {
 46 | 			return thrust::make_tuple(my_numeric_limits<NUMERIC>::max(), (Index)-1);
 47 | 		}
 48 | 
 49 | 		struct transformer : thrust::unary_function<Element, Element> {
 50 | 			__host__ __device__
 51 | 			Element operator()(const Element& v) const {
 52 | 				return v;
 53 | 			}
 54 | 		};
 55 | 
 56 | 		struct reducer : thrust::binary_function<Element, Element, Element> {
 57 | 			__host__ __device__
 58 | 			Element operator()(const Element& lhs, const Element& rhs) const {
 59 | 				return thrust::get<0>(lhs) < thrust::get<0>(rhs) ? lhs : rhs;
 60 | 			}
 61 | 		};
 62 | 	};
 63 | };
 64 | 
 65 | enum FEVMode {
 66 | 	FEV_THRUST,
 67 | 	// FEV_REDUCE_K0,
 68 | };
 69 | 
 70 | #ifndef FEV_MODE_DEFAULT
 71 | 	#define FEV_MODE_DEFAULT FEV_THRUST
 72 | #endif
 73 | static const bool fev_mode = FEV_MODE_DEFAULT;
 74 | 
 75 | #define FEV_BLOCK_HEIGHT ((int)16)
 76 | ptrdiff_t find_entering_variable(const util::PointerAndSize<double>& first_row) {
 77 | 	typedef FEVComputation<double> FEVComp;
 78 | 	typedef FEVComp::Index Index;
 79 | 
 80 | 	ptrdiff_t col_index = -1;
 81 | 	if (fev_mode == FEV_THRUST) {
 82 | 		FEVComp::Element reduced = thrust::transform_reduce(
 83 | 			thrust::cuda::par,
 84 | 			thrust::make_zip_iterator(thrust::make_tuple(
 85 | 				first_row.begin() + 1,
 86 | 				thrust::counting_iterator<ptrdiff_t>(1)
 87 | 			)),
 88 | 			thrust::make_zip_iterator(thrust::make_tuple(
 89 | 				first_row.end(),
 90 | 				thrust::counting_iterator<ptrdiff_t>(-1)
 91 | 			)),
 92 | 			FEVComp::Direct::transformer(),
 93 | 			FEVComp::Direct::identity(),
 94 | 			FEVComp::Direct::reducer()
 95 | 		);
 96 | 
 97 | 		if (thrust::get<0>(reduced) < 0) {
 98 | 			col_index = thrust::get<1>(reduced);
 99 | 		}
100 | 	}
101 | 
102 | 	if (col_index > 0) {
103 | 		std::cout << "      found entering variable: var" << col_index << '\n';
104 | 	} else {
105 | 		std::cout << "      did not find a entering variable\n";
106 | 	}
107 | 
108 | 	return col_index;
109 | }
110 | 
111 | #define K1_BLOCK_HEIGHT ((int)8)
112 | ThetaValuesAndEnteringColumn<double> get_theta_values_and_entering_column(const Tableau<double>& tab, VariableIndex entering) {
113 | 	assert(tab.height() % K1_BLOCK_HEIGHT == 0);
114 | 
115 | 	ThetaValuesAndEnteringColumn<double> result (
116 | 		tab.height()
117 | 	);
118 | 
119 | 	int numBlocks = tab.height()/K1_BLOCK_HEIGHT;
120 | 	int threadsPerBlock = K1_BLOCK_HEIGHT;
121 | 	kernel1<<<numBlocks, threadsPerBlock>>>(tab.data(), tab.width(), result.theta_values.data(), result.entering_column.data(), entering.getValue());
122 | 	cudaDeviceSynchronize();
123 | 
124 | 	return result;
125 | }
126 | 
127 | template<typename NUMERIC>
128 | struct FLVComputation {
129 | 	typedef ptrdiff_t Index;
130 | 	typedef thrust::tuple<NUMERIC,NUMERIC,Index> NumericTuple;
131 | 
132 | 	struct Direct {
133 | 		__host__ __device__
134 | 		static NumericTuple identity() {
135 | 			return thrust::make_tuple(my_numeric_limits<NUMERIC>::max(), 0.0f, (Index)-1);
136 | 		}
137 | 
138 | 		struct transformer : thrust::unary_function<NumericTuple, NumericTuple> {
139 | 			__host__ __device__
140 | 			NumericTuple operator()(const NumericTuple& v) const {
141 | 				if (thrust::get<1>(v) > 0) {
142 | 					return v;
143 | 				} else {
144 | 					return identity();
145 | 				}
146 | 			}
147 | 		};
148 | 
149 | 		struct reducer : thrust::binary_function<NumericTuple, NumericTuple, NumericTuple> {
150 | 			__host__ __device__
151 | 			NumericTuple operator()(const NumericTuple& lhs, const NumericTuple& rhs) const {
152 | 				return thrust::get<0>(lhs) < thrust::get<0>(rhs) ? lhs : rhs;
153 | 			}
154 | 		};
155 | 	};
156 | 
157 | 	struct Indirect {
158 | 		const NUMERIC* const theta_values;
159 | 		const NUMERIC* const entering_column;
160 | 
161 | 		Indirect(
162 | 			const ThetaValuesAndEnteringColumn<NUMERIC>& tv_and_centering_column
163 | 		)
164 | 			: theta_values(tv_and_centering_column.theta_values.data())
165 | 			, entering_column(tv_and_centering_column.entering_column.data())
166 | 		{ }
167 | 
168 | 		__host__ __device__
169 | 		Index identity() const { return -1; }
170 | 
171 | 		__host__ __device__
172 | 		Index should_reduce(const Index& v) const {
173 | 			if (v != identity() && entering_column[v] > 0) {
174 | 				return true;
175 | 			} else {
176 | 				// printf("ignoring %ld\n", v);
177 | 				return false;
178 | 			}
179 | 		}
180 | 
181 | 		__host__ __device__
182 | 		Index transform(const Index& v) const {
183 | 			if (should_reduce(v)) {
184 | 				return v;
185 | 			} else {
186 | 				return identity();
187 | 			}
188 | 		}
189 | 
190 | 		__host__ __device__
191 | 		Index reduce(const Index& lhs, const Index& rhs) const {
192 | 			if (lhs == identity()) {
193 | 				// printf("chooose: lhs=%ld, rhs=%d; RHS\n", lhs, rhs);
194 | 				return rhs;
195 | 			} else if (rhs == identity()) {
196 | 				// printf("chooose: lhs=%ld, rhs=%d; LHS\n", lhs, rhs);
197 | 				return lhs;
198 | 			} else {
199 | 				if (theta_values[lhs] < theta_values[rhs]) {
200 | 					// printf("chooose: lhs=%ld, rhs=%d; LHS\n", lhs, rhs);
201 | 					return lhs;
202 | 				} else {
203 | 					// printf("chooose: lhs=%ld, rhs=%d; RHS\n", lhs, rhs);
204 | 					return rhs;
205 | 				}
206 | 			}
207 | 		}
208 | 	};
209 | };
210 | 
211 | enum FLVMode {
212 | 	FLV_THRUST,
213 | 	FLV_REDUCE_K0,
214 | 	FLV_REDUCE_K6,
215 | };
216 | 
217 | #ifndef FLV_MODE_DEFAULT
218 | 	#define FLV_MODE_DEFAULT FLV_THRUST
219 | #endif
220 | static const bool flv_mode = FLV_MODE_DEFAULT;
221 | 
222 | #define FLV_BLOCK_HEIGHT ((int)16)
223 | ptrdiff_t find_leaving_variable(const ThetaValuesAndEnteringColumn<double>& tvals_and_centering) {
224 | 	typedef FLVComputation<double> FLVComp;
225 | 	typedef FLVComp::Index Index;
226 | 
227 | 	Index row_index = -1;
228 | 	if (flv_mode == FLV_THRUST) {
229 | 		row_index = thrust::get<2>(thrust::transform_reduce(
230 | 			thrust::cuda::par,
231 | 			thrust::make_zip_iterator(thrust::make_tuple(
232 | 				tvals_and_centering.theta_values.begin() + 1,
233 | 				tvals_and_centering.entering_column.begin() + 1,
234 | 				thrust::counting_iterator<Index>(1)
235 | 			)),
236 | 			thrust::make_zip_iterator(thrust::make_tuple(
237 | 				tvals_and_centering.theta_values.end(),
238 | 				tvals_and_centering.entering_column.end(),
239 | 				thrust::counting_iterator<Index>(-1)
240 | 			)),
241 | 			FLVComp::Direct::transformer(),
242 | 			FLVComp::Direct::identity(),
243 | 			FLVComp::Direct::reducer()
244 | 		));
245 | 	} else {
246 | 		const ptrdiff_t tab_height = tvals_and_centering.theta_values.size();
247 | 		assert(tab_height % FLV_BLOCK_HEIGHT == 0);
248 | 		assert(tvals_and_centering.entering_column.size() == tab_height);
249 | 
250 | 		thrust::device_vector<Index> row_index_storage(1);
251 | 
252 | 		static const int numBlocks = tab_height/FLV_BLOCK_HEIGHT;
253 | 		static const int threadsPerBlock = FLV_BLOCK_HEIGHT;
254 | 		static const int smemSize = (threadsPerBlock <= 32) ? 2 * threadsPerBlock * sizeof(Index) : threadsPerBlock * sizeof(Index);
255 | 
256 | 		if (flv_mode == FLV_REDUCE_K0) {
257 | 			reductions::reduce0<Index><<< numBlocks, threadsPerBlock, smemSize >>>(
258 | 				thrust::counting_iterator<Index>(1),
259 | 				row_index_storage.data().get(),
260 | 				tab_height - 1,
261 | 				FLVComp::Indirect(tvals_and_centering)
262 | 			);
263 | 			row_index = *row_index_storage.data();
264 | 		} else if (flv_mode == FLV_REDUCE_K6) {
265 | 			reductions::reduce6<Index, threadsPerBlock, true><<< numBlocks, threadsPerBlock, smemSize >>>(
266 | 				thrust::counting_iterator<Index>(1),
267 | 				row_index_storage.data().get(),
268 | 				tab_height - 1,
269 | 				FLVComp::Indirect(tvals_and_centering)
270 | 			);
271 | 			row_index = *row_index_storage.data();
272 | 		}
273 | 	}
274 | 
275 | 	if (row_index >= 0) {
276 | 		// emulate logging indentation
277 | 		std::cout << "      found leaving variable: var" << row_index << '\n';
278 | 	} else {
279 | 		std::cout << "      did not find a leaving variable\n";
280 | 	}
281 | 
282 | 	return row_index;
283 | }
284 | 
285 | #define K2_BLOCK_WIDTH ((int)512)
286 | void update_leaving_row(Tableau<double>& tab, const util::PointerAndSize<double>& entering_column, VariablePair leaving_and_entering) {
287 | 
288 | 	int numBlocks = tab.width()/K2_BLOCK_WIDTH;
289 | 	int threadsPerBlock = K2_BLOCK_WIDTH;
290 | 	kernel2<<<numBlocks, threadsPerBlock>>>(tab.data(), tab.width(), entering_column.data(), leaving_and_entering.leaving.getValue());
291 | }
292 | 
293 | #define K3_BLOCK_WIDTH ((int)128)
294 | #define K3_BLOCK_HEIGHT ((int)128)
295 | void update_rest_of_basis(Tableau<double>& tab, const util::PointerAndSize<double>& entering_column, VariableIndex leaving) {
296 | 	assert(tab.height() % K3_BLOCK_HEIGHT == 0);
297 | 	assert(tab.width()  % K3_BLOCK_WIDTH  == 0);
298 | 
299 | 	dim3 numBlocks(tab.width()/K3_BLOCK_WIDTH, tab.height()/K3_BLOCK_HEIGHT);
300 | 	dim3 threadsPerBlock(K3_BLOCK_WIDTH, K3_BLOCK_HEIGHT);
301 | 
302 | 	kernel3<<<numBlocks, threadsPerBlock>>>(tab.data(), tab.width(), tab.height(), entering_column.data(), leaving.getValue());
303 | }
304 | 
305 | #define K4_BLOCK_HEIGHT ((int)512)
306 | void update_entering_column(Tableau<double>& tab, const util::PointerAndSize<double>& entering_column, VariablePair leaving_and_entering) {
307 | 
308 | 	int numBlocks = tab.height()/K4_BLOCK_HEIGHT;
309 | 	int threadsPerBlock = K4_BLOCK_HEIGHT;
310 | 
311 | 	kernel4<<<numBlocks, threadsPerBlock>>>(tab.data(), tab.width(), entering_column.data(), leaving_and_entering.entering.getValue(), leaving_and_entering.leaving.getValue());
312 | }
313 | 
314 | 
315 | template<typename INTEGRAL>
316 | static INTEGRAL greatest_common_multiple(INTEGRAL a, INTEGRAL b) {
317 | 	while (true) {
318 | 		if (a == 0) return b;
319 | 		b %= a;
320 | 		if (b == 0) return a;
321 | 		a %= b;
322 | 	}
323 | }
324 | 
325 | template<typename IT>
326 | static int least_common_multiple(IT&& nums_begin, IT&& nums_end) {
327 | 	int result = *nums_begin;
328 | 	if (result == 0) { return 0; }
329 | 
330 | 	for (IT it = nums_begin; it != nums_end; ++it) {
331 | 		int num = *it;
332 | 		if (num == 0) { return 0; }
333 | 		result = (result*num)/greatest_common_multiple(num, result);
334 | 	}
335 | 
336 | 	return result;
337 | }
338 | 
339 | ProblemContraints problem_constraints() {
340 | 	int height_moduli[4] = {K1_BLOCK_HEIGHT, FLV_BLOCK_HEIGHT,  K3_BLOCK_HEIGHT, K4_BLOCK_HEIGHT, };
341 | 	int  width_moduli[2] = {K2_BLOCK_WIDTH,  K3_BLOCK_WIDTH, };
342 | 	return {
343 | 		least_common_multiple(&height_moduli[0], &height_moduli[sizeof(height_moduli)/sizeof(height_moduli[0])]),
344 | 		least_common_multiple(&width_moduli[0], &width_moduli[sizeof(width_moduli)/sizeof(width_moduli[0])]),
345 | 	};
346 | }
347 | 
348 | } // end namespace simplex
349 | } // end namespace gpu
350 | 
351 | 
352 | // kernel codes
353 | 
354 | __global__ void kernel1(double* SimplexTableau, int width, double* theta, double* columnK, int k) {
355 | 	int idx = blockDim.x * blockIdx.x + threadIdx.x;
356 | 	double w = SimplexTableau[idx*width + k];
357 | 	/*Copy the weights of entering index k*/
358 | 	columnK[idx] = w;
359 | 	theta[idx] = SimplexTableau[idx*width]/w;
360 | }
361 | 
362 | __global__ void kernel2(double* SimplexTableau, int width, const double* columnK, int r) {
363 | 	int idx = blockDim.x * blockIdx.x + threadIdx.x;
364 | 	__shared__ double w;
365 | 
366 | 	if (threadIdx.x == 0) {
367 | 		w = columnK[r];
368 | 		// printf("index: %d\n", r);
369 | 		// printf("denom: %f\n", w);
370 | 		// printf("width: %d\n", width);
371 | 	}
372 | 	__syncthreads();
373 | 
374 | 
375 | 	// printf("idx: %d %f\n", idx, SimplexTableau[r*width + idx]);
376 | 	SimplexTableau[r*width + idx] = SimplexTableau[r*width + idx]/w;
377 | }
378 | 
379 | __global__ void kernel3(double* SimplexTableau, int width, int height, const double* columnK, int r) {
380 | 	int idx = blockDim.x * blockIdx.x + threadIdx.x;
381 | 	int jdx = blockIdx.y * blockDim.y + threadIdx.y;
382 | 	__shared__ double w[K3_BLOCK_WIDTH];
383 | 
384 | 	/*Get the column of entering index k in shared memory */
385 | 	// The K3_BLOCK_WIDTH test is redundant??
386 | 	if(threadIdx.y == 0 && threadIdx.x < K3_BLOCK_WIDTH)
387 | 	{
388 | 		w[threadIdx.x] = columnK[blockIdx.y * blockDim.y+threadIdx.x];
389 | 		// printf("columnK[%d*%d + %d = %d] %f\n", blockIdx.y, blockDim.y, threadIdx.x, blockIdx.y * blockDim.y+threadIdx.x, columnK[blockIdx.y * blockDim.y+threadIdx.x]);
390 | 	}
391 | 	__syncthreads();
392 | 	/*Update the basis except the line r*/
393 | 	if(jdx == r) return;
394 | 	// printf("w[threadIdx.y]: %f SimplexTableau[r*width + idx]: %f r: %d idx: %d\n", w[threadIdx.y], SimplexTableau[r*width + idx], r, idx);
395 | 	SimplexTableau[jdx*width + idx] -= w[threadIdx.y] * SimplexTableau[r*width + idx];
396 | }
397 | 
398 | __global__ void kernel4(double* SimplexTableau, int width, const double* columnK, int k, int r) {
399 | 	int jdx = blockDim.x * blockIdx.x + threadIdx.x;
400 | 	__shared__ double w;
401 | 	/*Get the pivot element : SimplexT ableau[r][k] in the
402 | 	shared memory */
403 | 	if(threadIdx.x == 0){
404 | 		w = columnK[r];
405 | 		// printf("r: %d w %f\n", r,w);
406 | 	}
407 | 	__syncthreads();
408 | 	/*Update the column of the entering index k*/
409 | 	SimplexTableau[jdx*width + k] = -columnK[jdx]/w;
410 | 
411 | 	/*Update the pivot element SimplexT ableau[r][k]*/
412 | 	if(jdx == r) SimplexTableau[jdx*width + k]=1/w;
413 | 
414 | }


--------------------------------------------------------------------------------
/src/impl/reduction_kernel.cu:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 1993-2015 NVIDIA Corporation.  All rights reserved.
  3 |  *
  4 |  * This software contains source code provided by NVIDIA Corporation.
  5 |  *
  6 |  * Some significant generification modifications have been made.
  7 |  */
  8 | 
  9 | #ifndef IMPL__REDUCE_KERNEL_H
 10 | #define IMPL__REDUCE_KERNEL_H
 11 | 
 12 | namespace reductions {
 13 | 
 14 | // Utility class used to avoid linker errors with extern
 15 | // unsized shared memory arrays with templated type
 16 | template<class T>
 17 | struct SharedMemory {
 18 | 	__device__ inline operator       T *() {
 19 | 		extern __shared__ int __smem[];
 20 | 		return (T *)__smem;
 21 | 	}
 22 | 
 23 | 	__device__ inline operator const T *() const {
 24 | 		extern __shared__ int __smem[];
 25 | 		return (T *)__smem;
 26 | 	}
 27 | };
 28 | 
 29 | // specialize for double to avoid unaligned memory
 30 | // access compile errors
 31 | template<>
 32 | struct SharedMemory<double> {
 33 | 	__device__ inline operator       double *() {
 34 | 		extern __shared__ double __smem_d[];
 35 | 		return (double *)__smem_d;
 36 | 	}
 37 | 
 38 | 	__device__ inline operator const double *() const {
 39 | 		extern __shared__ double __smem_d[];
 40 | 		return (double *)__smem_d;
 41 | 	}
 42 | };
 43 | 
 44 | /*
 45 | 	Parallel sum reduction using shared memory
 46 | 	- takes log(n) steps for n input elements
 47 | 	- uses n threads
 48 | 	- only works for power-of-2 arrays
 49 | */
 50 | 
 51 | /* This reduction interleaves which threads are active by using the modulo
 52 | 	operator.  This operator is very expensive on GPUs, and the interleaved
 53 | 	inactivity means that no whole warps are active, which is also very
 54 | 	inefficient */
 55 | template <class T, typename InputIt, typename Computation>
 56 | __global__ void
 57 | reduce0(InputIt g_idata, T* g_odata, unsigned int n, Computation c) {
 58 | 	T* sdata = SharedMemory<T>();
 59 | 
 60 | 	// load shared mem
 61 | 	unsigned int tid = threadIdx.x;
 62 | 	unsigned int i = blockIdx.x*blockDim.x + threadIdx.x;
 63 | 
 64 | 	sdata[tid] = (i < n) ? c.transform(g_idata[i]) : c.identity();
 65 | 
 66 | 	__syncthreads();
 67 | 
 68 | 	// do reduction in shared mem
 69 | 	for (unsigned int s=1; s < blockDim.x; s *= 2) {
 70 | 		// modulo arithmetic is slow!
 71 | 		if ((tid % (2*s)) == 0) {
 72 | 			sdata[tid] = c.reduce(sdata[tid], sdata[tid + s]);
 73 | 		}
 74 | 
 75 | 		__syncthreads();
 76 | 	}
 77 | 
 78 | 	// write result for this block to global mem
 79 | 	if (tid == 0) *g_odata = sdata[0];
 80 | }
 81 | 
 82 | /* This version uses contiguous threads, but its interleaved
 83 |    addressing results in many shared memory bank conflicts.
 84 | */
 85 | template <class T>
 86 | __global__ void
 87 | reduce1(T* g_idata, T* g_odata, unsigned int n) {
 88 | 	T* sdata = SharedMemory<T>();
 89 | 
 90 | 	// load shared mem
 91 | 	unsigned int tid = threadIdx.x;
 92 | 	unsigned int i = blockIdx.x*blockDim.x + threadIdx.x;
 93 | 
 94 | 	sdata[tid] = (i < n) ? g_idata[i] : 0;
 95 | 
 96 | 	__syncthreads();
 97 | 
 98 | 	// do reduction in shared mem
 99 | 	for (unsigned int s=1; s < blockDim.x; s *= 2) {
100 | 		int index = 2 * s * tid;
101 | 
102 | 		if (index < blockDim.x) {
103 | 			sdata[index] += sdata[index + s];
104 | 		}
105 | 
106 | 		__syncthreads();
107 | 	}
108 | 
109 | 	// write result for this block to global mem
110 | 	if (tid == 0) g_odata[blockIdx.x] = sdata[0];
111 | }
112 | 
113 | /*
114 | 	This version uses sequential addressing -- no divergence or bank conflicts.
115 | */
116 | template <class T>
117 | __global__ void
118 | reduce2(T* g_idata, T* g_odata, unsigned int n) {
119 | 	T* sdata = SharedMemory<T>();
120 | 
121 | 	// load shared mem
122 | 	unsigned int tid = threadIdx.x;
123 | 	unsigned int i = blockIdx.x*blockDim.x + threadIdx.x;
124 | 
125 | 	sdata[tid] = (i < n) ? g_idata[i] : 0;
126 | 
127 | 	__syncthreads();
128 | 
129 | 	// do reduction in shared mem
130 | 	for (unsigned int s=blockDim.x/2; s>0; s>>=1) {
131 | 		if (tid < s) {
132 | 			sdata[tid] += sdata[tid + s];
133 | 		}
134 | 
135 | 		__syncthreads();
136 | 	}
137 | 
138 | 	// write result for this block to global mem
139 | 	if (tid == 0) g_odata[blockIdx.x] = sdata[0];
140 | }
141 | 
142 | /*
143 | 	This version uses n/2 threads --
144 | 	it performs the first level of reduction when reading from global memory.
145 | */
146 | template <class T>
147 | __global__ void
148 | reduce3(T* g_idata, T* g_odata, unsigned int n) {
149 | 	T* sdata = SharedMemory<T>();
150 | 
151 | 	// perform first level of reduction,
152 | 	// reading from global memory, writing to shared memory
153 | 	unsigned int tid = threadIdx.x;
154 | 	unsigned int i = blockIdx.x*(blockDim.x*2) + threadIdx.x;
155 | 
156 | 	T mySum = (i < n) ? g_idata[i] : 0;
157 | 
158 | 	if (i + blockDim.x < n)
159 | 		mySum += g_idata[i+blockDim.x];
160 | 
161 | 	sdata[tid] = mySum;
162 | 	__syncthreads();
163 | 
164 | 	// do reduction in shared mem
165 | 	for (unsigned int s=blockDim.x/2; s>0; s>>=1) {
166 | 		if (tid < s) {
167 | 			sdata[tid] = mySum = mySum + sdata[tid + s];
168 | 		}
169 | 
170 | 		__syncthreads();
171 | 	}
172 | 
173 | 	// write result for this block to global mem
174 | 	if (tid == 0) g_odata[blockIdx.x] = mySum;
175 | }
176 | 
177 | /*
178 | 	This version uses the warp shuffle operation if available to reduce
179 | 	warp synchronization. When shuffle is not available the final warp's
180 | 	worth of work is unrolled to reduce looping overhead.
181 | 
182 | 	See http://devblogs.nvidia.com/parallelforall/faster-parallel-reductions-kepler/
183 | 	for additional information about using shuffle to perform a reduction
184 | 	within a warp.
185 | 
186 | 	Note, this kernel needs a minimum of 64*sizeof(T) bytes of shared memory.
187 | 	In other words if blockSize <= 32, allocate 64*sizeof(T) bytes.
188 | 	If blockSize > 32, allocate blockSize*sizeof(T) bytes.
189 | */
190 | template <class T, unsigned int blockSize>
191 | __global__ void
192 | reduce4(T* g_idata, T* g_odata, unsigned int n) {
193 | 	T* sdata = SharedMemory<T>();
194 | 
195 | 	// perform first level of reduction,
196 | 	// reading from global memory, writing to shared memory
197 | 	unsigned int tid = threadIdx.x;
198 | 	unsigned int i = blockIdx.x*(blockDim.x*2) + threadIdx.x;
199 | 
200 | 	T mySum = (i < n) ? g_idata[i] : 0;
201 | 
202 | 	if (i + blockSize < n)
203 | 		mySum += g_idata[i+blockSize];
204 | 
205 | 	sdata[tid] = mySum;
206 | 	__syncthreads();
207 | 
208 | 	// do reduction in shared mem
209 | 	for (unsigned int s=blockDim.x/2; s>32; s>>=1) {
210 | 		if (tid < s) {
211 | 			sdata[tid] = mySum = mySum + sdata[tid + s];
212 | 		}
213 | 
214 | 		__syncthreads();
215 | 	}
216 | 
217 | #if (__CUDA_ARCH__ >= 300 )
218 | 	if ( tid < 32 ) {
219 | 		// Fetch final intermediate sum from 2nd warp
220 | 		if (blockSize >=  64) mySum += sdata[tid + 32];
221 | 		// Reduce final warp using shuffle
222 | 		for (int offset = warpSize/2; offset > 0; offset /= 2) {
223 | 			mySum += __shfl_down(mySum, offset);
224 | 		}
225 | 	}
226 | #else
227 | 	// fully unroll reduction within a single warp
228 | 	if ((blockSize >=  64) && (tid < 32)) {
229 | 		sdata[tid] = mySum = mySum + sdata[tid + 32];
230 | 	}
231 | 
232 | 	__syncthreads();
233 | 
234 | 	if ((blockSize >=  32) && (tid < 16)) {
235 | 		sdata[tid] = mySum = mySum + sdata[tid + 16];
236 | 	}
237 | 
238 | 	__syncthreads();
239 | 
240 | 	if ((blockSize >=  16) && (tid <  8)) {
241 | 		sdata[tid] = mySum = mySum + sdata[tid +  8];
242 | 	}
243 | 
244 | 	__syncthreads();
245 | 
246 | 	if ((blockSize >=   8) && (tid <  4)) {
247 | 		sdata[tid] = mySum = mySum + sdata[tid +  4];
248 | 	}
249 | 
250 | 	__syncthreads();
251 | 
252 | 	if ((blockSize >=   4) && (tid <  2)) {
253 | 		sdata[tid] = mySum = mySum + sdata[tid +  2];
254 | 	}
255 | 
256 | 	__syncthreads();
257 | 
258 | 	if ((blockSize >=   2) && ( tid <  1)) {
259 | 		sdata[tid] = mySum = mySum + sdata[tid +  1];
260 | 	}
261 | 
262 | 	__syncthreads();
263 | #endif
264 | 
265 | 	// write result for this block to global mem
266 | 	if (tid == 0) g_odata[blockIdx.x] = mySum;
267 | }
268 | 
269 | /*
270 | 	This version is completely unrolled, unless warp shuffle is available, then
271 | 	shuffle is used within a loop.  It uses a template parameter to achieve
272 | 	optimal code for any (power of 2) number of threads.  This requires a switch
273 | 	statement in the host code to handle all the different thread block sizes at
274 | 	compile time. When shuffle is available, it is used to reduce warp synchronization.
275 | 
276 | 	Note, this kernel needs a minimum of 64*sizeof(T) bytes of shared memory.
277 | 	In other words if blockSize <= 32, allocate 64*sizeof(T) bytes.
278 | 	If blockSize > 32, allocate blockSize*sizeof(T) bytes.
279 | */
280 | template <class T, unsigned int blockSize>
281 | __global__ void
282 | reduce5(T* g_idata, T* g_odata, unsigned int n) {
283 | 	T* sdata = SharedMemory<T>();
284 | 
285 | 	// perform first level of reduction,
286 | 	// reading from global memory, writing to shared memory
287 | 	unsigned int tid = threadIdx.x;
288 | 	unsigned int i = blockIdx.x*(blockSize*2) + threadIdx.x;
289 | 
290 | 	T mySum = (i < n) ? g_idata[i] : 0;
291 | 
292 | 	if (i + blockSize < n)
293 | 		mySum += g_idata[i+blockSize];
294 | 
295 | 	sdata[tid] = mySum;
296 | 	__syncthreads();
297 | 
298 | 	// do reduction in shared mem
299 | 	if ((blockSize >= 512) && (tid < 256)) {
300 | 		sdata[tid] = mySum = mySum + sdata[tid + 256];
301 | 	}
302 | 
303 | 	__syncthreads();
304 | 
305 | 	if ((blockSize >= 256) &&(tid < 128)) {
306 | 		sdata[tid] = mySum = mySum + sdata[tid + 128];
307 | 	}
308 | 
309 | 	 __syncthreads();
310 | 
311 | 	if ((blockSize >= 128) && (tid <  64)) {
312 | 		sdata[tid] = mySum = mySum + sdata[tid +  64];
313 | 	}
314 | 
315 | 	__syncthreads();
316 | 
317 | #if (__CUDA_ARCH__ >= 300 )
318 | 	if ( tid < 32 ) {
319 | 		// Fetch final intermediate sum from 2nd warp
320 | 		if (blockSize >=  64) mySum += sdata[tid + 32];
321 | 		// Reduce final warp using shuffle
322 | 		for (int offset = warpSize/2; offset > 0; offset /= 2) {
323 | 			mySum += __shfl_down(mySum, offset);
324 | 		}
325 | 	}
326 | #else
327 | 	// fully unroll reduction within a single warp
328 | 	if ((blockSize >=  64) && (tid < 32)) {
329 | 		sdata[tid] = mySum = mySum + sdata[tid + 32];
330 | 	}
331 | 
332 | 	__syncthreads();
333 | 
334 | 	if ((blockSize >=  32) && (tid < 16)) {
335 | 		sdata[tid] = mySum = mySum + sdata[tid + 16];
336 | 	}
337 | 
338 | 	__syncthreads();
339 | 
340 | 	if ((blockSize >=  16) && (tid <  8)) {
341 | 		sdata[tid] = mySum = mySum + sdata[tid +  8];
342 | 	}
343 | 
344 | 	__syncthreads();
345 | 
346 | 	if ((blockSize >=   8) && (tid <  4)) {
347 | 		sdata[tid] = mySum = mySum + sdata[tid +  4];
348 | 	}
349 | 
350 | 	__syncthreads();
351 | 
352 | 	if ((blockSize >=   4) && (tid <  2)) {
353 | 		sdata[tid] = mySum = mySum + sdata[tid +  2];
354 | 	}
355 | 
356 | 	__syncthreads();
357 | 
358 | 	if ((blockSize >=   2) && ( tid <  1)) {
359 | 		sdata[tid] = mySum = mySum + sdata[tid +  1];
360 | 	}
361 | 
362 | 	__syncthreads();
363 | #endif
364 | 
365 | 	// write result for this block to global mem
366 | 	if (tid == 0) g_odata[blockIdx.x] = mySum;
367 | }
368 | 
369 | /*
370 | 	This version adds multiple elements per thread sequentially.  This reduces the overall
371 | 	cost of the algorithm while keeping the work complexity O(n) and the step complexity O(log n).
372 | 	(Brent's Theorem optimization)
373 | 
374 | 	Note, this kernel needs a minimum of 64*sizeof(T) bytes of shared memory.
375 | 	In other words if blockSize <= 32, allocate 64*sizeof(T) bytes.
376 | 	If blockSize > 32, allocate blockSize*sizeof(T) bytes.
377 | */
378 | template <class T, unsigned int blockSize, bool nIsPow2, typename InputIt, typename Computation>
379 | __global__ void
380 | reduce6(InputIt g_idata, T* g_odata, unsigned int n, Computation c) {
381 | 	T* sdata = SharedMemory<T>();
382 | 
383 | 	// perform first level of reduction,
384 | 	// reading from global memory, writing to shared memory
385 | 	unsigned int tid = threadIdx.x;
386 | 	unsigned int i = blockIdx.x*blockSize*2 + threadIdx.x;
387 | 	unsigned int gridSize = blockSize*2*gridDim.x;
388 | 
389 | 	T mySum = c.identity();
390 | 
391 | 	// we reduce multiple elements per thread.  The number is determined by the
392 | 	// number of active thread blocks (via gridDim).  More blocks will result
393 | 	// in a larger gridSize and therefore fewer elements per thread
394 | 	while (i < n) {
395 | 		mySum = c.reduce(mySum, c.transform(g_idata[i]));
396 | 
397 | 		// ensure we don't read out of bounds -- this is optimized away for powerOf2 sized arrays
398 | 		if (nIsPow2 || i + blockSize < n)
399 | 			mySum = c.reduce(mySum, c.transform(g_idata[i+blockSize]));
400 | 
401 | 		i += gridSize;
402 | 	}
403 | 
404 | 	// each thread puts its local sum into shared memory
405 | 	sdata[tid] = mySum;
406 | 	__syncthreads();
407 | 
408 | 
409 | 	// do reduction in shared mem
410 | 	if ((blockSize >= 512) && (tid < 256)) {
411 | 		sdata[tid] = mySum = c.reduce(mySum, sdata[tid + 256]);
412 | 	}
413 | 
414 | 	__syncthreads();
415 | 
416 | 	if ((blockSize >= 256) &&(tid < 128)) {
417 | 		sdata[tid] = mySum = c.reduce(mySum, sdata[tid + 128]);
418 | 	}
419 | 
420 | 	 __syncthreads();
421 | 
422 | 	if ((blockSize >= 128) && (tid <  64)) {
423 | 	   sdata[tid] = mySum = c.reduce(mySum, sdata[tid +  64]);
424 | 	}
425 | 
426 | 	__syncthreads();
427 | 
428 | #if (__CUDA_ARCH__ >= 300 )
429 | 	if ( tid < 32 ) {
430 | 		// Fetch final intermediate sum from 2nd warp
431 | 		if (blockSize >=  64) mySum = c.reduce(mySum, sdata[tid + 32]);
432 | 		// Reduce final warp using shuffle
433 | 		for (int offset = warpSize/2; offset > 0; offset /= 2) {
434 | 			mySum = c.reduce(mySum, __shfl_down(mySum, offset));
435 | 		}
436 | 	}
437 | #else
438 | 	// fully unroll reduction within a single warp
439 | 	if ((blockSize >=  64) && (tid < 32)) {
440 | 		sdata[tid] = mySum = c.reduce(mySum, sdata[tid + 32]);
441 | 	}
442 | 
443 | 	__syncthreads();
444 | 
445 | 	if ((blockSize >=  32) && (tid < 16)) {
446 | 		sdata[tid] = mySum = c.reduce(mySum, sdata[tid + 16]);
447 | 	}
448 | 
449 | 	__syncthreads();
450 | 
451 | 	if ((blockSize >=  16) && (tid <  8)) {
452 | 		sdata[tid] = mySum = c.reduce(mySum, sdata[tid +  8]);
453 | 	}
454 | 
455 | 	__syncthreads();
456 | 
457 | 	if ((blockSize >=   8) && (tid <  4)) {
458 | 		sdata[tid] = mySum = c.reduce(mySum, sdata[tid +  4]);
459 | 	}
460 | 
461 | 	__syncthreads();
462 | 
463 | 	if ((blockSize >=   4) && (tid <  2)) {
464 | 		sdata[tid] = mySum = c.reduce(mySum, sdata[tid +  2]);
465 | 	}
466 | 
467 | 	__syncthreads();
468 | 
469 | 	if ((blockSize >=   2) && ( tid <  1)) {
470 | 		sdata[tid] = mySum = c.reduce(mySum, sdata[tid +  1]);
471 | 	}
472 | 
473 | 	__syncthreads();
474 | #endif
475 | 
476 | 	// write result for this block to global mem
477 | 	if (tid == 0) g_odata[blockIdx.x] = mySum;
478 | }
479 | 
480 | extern "C"
481 | bool isPow2(unsigned int x) {
482 | 	return ((x&(x-1))==0);
483 | }
484 | 
485 | ////////////////////////////////////////////////////////////////////////////////
486 | // Wrapper function for kernel launch
487 | ////////////////////////////////////////////////////////////////////////////////
488 | // template <class T>
489 | // void
490 | // reduce(int size, int threads, int blocks,
491 | // 	   int whichKernel, T* d_idata, T* d_odata) {
492 | // 	dim3 dimBlock(threads, 1, 1);
493 | // 	dim3 dimGrid(blocks, 1, 1);
494 | 
495 | // 	// when there is only one warp per block, we need to allocate two warps
496 | // 	// worth of shared memory so that we don't index shared memory out of bounds
497 | // 	int smemSize = (threads <= 32) ? 2 * threads * sizeof(T) : threads * sizeof(T);
498 | 
499 | // 	// choose which of the optimized versions of reduction to launch
500 | // 	switch (whichKernel) {
501 | // 		case 0:
502 | // 			reduce0<T><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
503 | // 			break;
504 | 
505 | // 		case 1:
506 | // 			reduce1<T><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
507 | // 			break;
508 | 
509 | // 		case 2:
510 | // 			reduce2<T><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
511 | // 			break;
512 | 
513 | // 		case 3:
514 | // 			reduce3<T><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
515 | // 			break;
516 | 
517 | // 		case 4:
518 | // 			switch (threads) {
519 | // 				case 512:
520 | // 					reduce4<T, 512><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
521 | // 					break;
522 | 
523 | // 				case 256:
524 | // 					reduce4<T, 256><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
525 | // 					break;
526 | 
527 | // 				case 128:
528 | // 					reduce4<T, 128><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
529 | // 					break;
530 | 
531 | // 				case 64:
532 | // 					reduce4<T,  64><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
533 | // 					break;
534 | 
535 | // 				case 32:
536 | // 					reduce4<T,  32><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
537 | // 					break;
538 | 
539 | // 				case 16:
540 | // 					reduce4<T,  16><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
541 | // 					break;
542 | 
543 | // 				case  8:
544 | // 					reduce4<T,   8><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
545 | // 					break;
546 | 
547 | // 				case  4:
548 | // 					reduce4<T,   4><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
549 | // 					break;
550 | 
551 | // 				case  2:
552 | // 					reduce4<T,   2><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
553 | // 					break;
554 | 
555 | // 				case  1:
556 | // 					reduce4<T,   1><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
557 | // 					break;
558 | // 			}
559 | 
560 | // 			break;
561 | 
562 | // 		case 5:
563 | // 			switch (threads) {
564 | // 				case 512:
565 | // 					reduce5<T, 512><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
566 | // 					break;
567 | 
568 | // 				case 256:
569 | // 					reduce5<T, 256><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
570 | // 					break;
571 | 
572 | // 				case 128:
573 | // 					reduce5<T, 128><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
574 | // 					break;
575 | 
576 | // 				case 64:
577 | // 					reduce5<T,  64><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
578 | // 					break;
579 | 
580 | // 				case 32:
581 | // 					reduce5<T,  32><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
582 | // 					break;
583 | 
584 | // 				case 16:
585 | // 					reduce5<T,  16><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
586 | // 					break;
587 | 
588 | // 				case  8:
589 | // 					reduce5<T,   8><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
590 | // 					break;
591 | 
592 | // 				case  4:
593 | // 					reduce5<T,   4><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
594 | // 					break;
595 | 
596 | // 				case  2:
597 | // 					reduce5<T,   2><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
598 | // 					break;
599 | 
600 | // 				case  1:
601 | // 					reduce5<T,   1><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
602 | // 					break;
603 | // 			}
604 | 
605 | // 			break;
606 | 
607 | // 		case 6:
608 | // 		default:
609 | // 			if (isPow2(size)) {
610 | // 				switch (threads) {
611 | // 					case 512:
612 | // 						reduce6<T, 512, true><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
613 | // 						break;
614 | 
615 | // 					case 256:
616 | // 						reduce6<T, 256, true><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
617 | // 						break;
618 | 
619 | // 					case 128:
620 | // 						reduce6<T, 128, true><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
621 | // 						break;
622 | 
623 | // 					case 64:
624 | // 						reduce6<T,  64, true><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
625 | // 						break;
626 | 
627 | // 					case 32:
628 | // 						reduce6<T,  32, true><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
629 | // 						break;
630 | 
631 | // 					case 16:
632 | // 						reduce6<T,  16, true><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
633 | // 						break;
634 | 
635 | // 					case  8:
636 | // 						reduce6<T,   8, true><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
637 | // 						break;
638 | 
639 | // 					case  4:
640 | // 						reduce6<T,   4, true><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
641 | // 						break;
642 | 
643 | // 					case  2:
644 | // 						reduce6<T,   2, true><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
645 | // 						break;
646 | 
647 | // 					case  1:
648 | // 						reduce6<T,   1, true><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
649 | // 						break;
650 | // 				}
651 | // 			}
652 | // 			else {
653 | // 				switch (threads) {
654 | // 					case 512:
655 | // 						reduce6<T, 512, false><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
656 | // 						break;
657 | 
658 | // 					case 256:
659 | // 						reduce6<T, 256, false><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
660 | // 						break;
661 | 
662 | // 					case 128:
663 | // 						reduce6<T, 128, false><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
664 | // 						break;
665 | 
666 | // 					case 64:
667 | // 						reduce6<T,  64, false><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
668 | // 						break;
669 | 
670 | // 					case 32:
671 | // 						reduce6<T,  32, false><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
672 | // 						break;
673 | 
674 | // 					case 16:
675 | // 						reduce6<T,  16, false><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
676 | // 						break;
677 | 
678 | // 					case  8:
679 | // 						reduce6<T,   8, false><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
680 | // 						break;
681 | 
682 | // 					case  4:
683 | // 						reduce6<T,   4, false><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
684 | // 						break;
685 | 
686 | // 					case  2:
687 | // 						reduce6<T,   2, false><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
688 | // 						break;
689 | 
690 | // 					case  1:
691 | // 						reduce6<T,   1, false><<< dimGrid, dimBlock, smemSize >>>(d_idata, d_odata, size);
692 | // 						break;
693 | // 				}
694 | // 			}
695 | 
696 | // 			break;
697 | // 	}
698 | // }
699 | 
700 | } // end namespace reductions
701 | 
702 | #endif // #ifndef IMPL__REDUCE_KERNEL_H
703 | 


--------------------------------------------------------------------------------