Merge branch 'ch-fix-gl-build-deploy' into 'master' (317bb1ff) · Commits · Michael Tesch / cppduals

.gitlab-ci.yml

+18 −15

Original line number	Diff line number	Diff line
		@@ -20,7 +20,6 @@ stages:
		before_script:
		#- apt-get update --yes
		#- apt-get install --yes cmake g++ git doxygen lcov graphviz
		- dnf install -y gcc-c++ make cmake git doxygen lcov graphviz

		build:
		stage: build
		@@ -28,49 +27,53 @@ build:
		# CC: clang
		# CXX: clang++ script:
		script:
		- dnf install -y gcc-c++ make cmake git doxygen lcov graphviz
		- echo $CXX
		- cmake -Bbuild -H. -DCPPDUALS_TESTING=ON
		- cmake -Bbuild -H. -DCPPDUALS_TESTING=ON -DCMAKE_BUILD_TYPE=RelWithDebInfo
		- cmake --build build
		- cmake -Bbuild-latest -H. -DCPPDUALS_TESTING=ON -DCPPDUALS_EIGEN_LATEST=ON
		- cmake --build build-latest
		# - cmake -Bbuild-latest -H. -DCPPDUALS_TESTING=ON -DCPPDUALS_EIGEN_LATEST=ON
		# - cmake --build build-latest
		artifacts:
		expire_in: 1 week
		paths:
		- build
		- build-latest
		- build/
		# - build-latest

		test:
		stage: test
		script:
		- dnf install -y gcc-c++ make cmake git doxygen lcov graphviz
		- cmake --build build --target test
		- cmake --build build-latest --target test
		# - cmake --build build-latest --target test
		dependencies:
		- build

		cover:
		script:
		- dnf install -y gcc-c++ make cmake git doxygen lcov graphviz
		- cmake -Bbuild-cov -H. -DCODE_COVERAGE=ON -DCPPDUALS_TESTING=ON
		- cmake --build build-cov --target cov
		- cmake --build build-cov --target cov-html
		coverage: "/Total:\|\\w*\\d+\\.\\d+/"
		artifacts:
		expire_in: 1 day
		expire_in: 1 week
		paths:
		- build-cov
		- build-cov/
		only:
		- merge_requests

		pages:
		script:
		- cmake -Bbuild -H. -DCODE_COVERAGE=ON -DCPPDUALS_TESTING=ON
		- cmake --build build --target cppduals_docs
		- cmake --build build --target cov-html
		- mv build/docs public/
		- mv build/coverage public/
		- dnf install -y gcc-c++ make cmake git doxygen lcov graphviz
		- cmake -Bbuild-cov -H. -DCODE_COVERAGE=ON -DCPPDUALS_TESTING=ON
		- cmake --build build-cov --target cppduals_docs
		- cmake --build build-cov --target cov-html
		- mv build-cov/docs public/
		- mv build-cov/coverage public/
		coverage: "/Total:\|\\w*\\d+\\.\\d+/"
		artifacts:
		paths:
		- public
		- public/
		only:
		- master

CMakeLists.txt

+2 −2

Original line number	Diff line number	Diff line
		#
		# CMake for cppduals
		#
		cmake_minimum_required (VERSION 3.1)
		cmake_minimum_required (VERSION 3.12)
		project (cppduals
		VERSION 0.5.2
		VERSION 0.5.3
		LANGUAGES C CXX
		)
		include (GNUInstallDirs)

duals/arch/NEON/ComplexDual.h

+25 −25

Original line number	Diff line number	Diff line
		@@ -69,7 +69,7 @@ template<> EIGEN_STRONG_INLINE Packet1cdf pnegate(const Packet1cdf& a) { return
		template<> EIGEN_STRONG_INLINE Packet1cdf pconj(const Packet1cdf& a)
		{
		uint32x4_t mask = { 0x00000000, 0x00000000, 0x80000000, 0x80000000 };
		return Packet1cdf(vreinterpretq_f32_u32(veorq_u32(a.v.v, mask)));
		return Packet1cdf(vreinterpretq_f32_u32(veorq_u32(vreinterpretq_u32_f32(a.v.v), mask)));
		}

		template<> EIGEN_STRONG_INLINE Packet1cdf pmul<Packet1cdf>(const Packet1cdf& a, const Packet1cdf& b)
		@@ -82,36 +82,36 @@ template<> EIGEN_STRONG_INLINE Packet1cdf pmul<Packet1cdf>(const Packet1cdf& a,
		//
		uint32x4_t mask = {0x00000000, 0xffffffff, 0x00000000, 0xffffffff};
		uint32x4_t nega = {0x80000000, 0x80000000, 0x00000000, 0x00000000};
		return Packet1cdf(vaddq_f32(vaddq_f32(vmulq_f32(vdupq_lane_u32(vget_low_f32(a.v.v), 0),
		return Packet1cdf(vaddq_f32(vaddq_f32(vmulq_f32(vdupq_lane_f32(vget_low_f32(a.v.v), 0),
		b.v.v),
		vandq_u32(mask,
		vmulq_f32(vdupq_lane_u64(vget_low_u64(a.v.v), 0),
		vcombine_u64(vdup_lane_u32(vget_low_u32(b.v.v), 0),
		vsli_n_u64(vdup_lane_u32(vget_low_u32(b.v.v), 0),
		vget_high_u64(b.v.v), 32))))),
		veorq_u32
		(float32x4_t)vandq_u32(mask,
		(uint32x4_t)vmulq_f32((float32x4_t)vdupq_lane_u64(vget_low_u64((uint64x2_t)a.v.v), 0),
		(float32x4_t)vcombine_u64((uint64x1_t)vdup_lane_u32(vget_low_u32((uint32x4_t)b.v.v), 0),
		vsli_n_u64((uint64x1_t)vdup_lane_u32(vget_low_u32((uint32x4_t)b.v.v), 0),
		vget_high_u64((uint64x2_t)b.v.v), 32))))),
		(float32x4_t)veorq_u32
		(nega,
		vaddq_f32(vmulq_f32(vdupq_lane_u32(vget_high_f32(a.v.v), 0),
		vcombine_u64(vget_high_u64(b.v.v),
		vget_low_u64(b.v.v))),
		vandq_u32(mask,
		vmulq_f32(vsriq_n_u64(vcombine_u64(vget_high_u64(a.v.v),
		vget_high_u64(a.v.v)),
		vshlq_n_u64(vcombine_u64(vget_low_u64(a.v.v),
		vget_low_u64(a.v.v)), 32), 32),
		vcombine_u64(vsli_n_u64(vget_low_u64(b.v.v),
		vget_high_u64(b.v.v), 32),
		vdup_lane_u32(vget_low_u32(b.v.v), 0))))))));
		(uint32x4_t)vaddq_f32(vmulq_f32(vdupq_lane_f32(vget_high_f32(a.v.v), 0),
		(float32x4_t)vcombine_u64(vget_high_u64((uint64x2_t)b.v.v),
		vget_low_u64((uint64x2_t)b.v.v))),
		(float32x4_t)vandq_u32(mask,
		(uint32x4_t)vmulq_f32((float32x4_t)vsriq_n_u64(vcombine_u64(vget_high_u64((uint64x2_t)a.v.v),
		vget_high_u64((uint64x2_t)a.v.v)),
		vshlq_n_u64(vcombine_u64(vget_low_u64((uint64x2_t)a.v.v),
		vget_low_u64((uint64x2_t)a.v.v)), 32), 32),
		(float32x4_t)vcombine_u64(vsli_n_u64(vget_low_u64((uint64x2_t)b.v.v),
		vget_high_u64((uint64x2_t)b.v.v), 32),
		(uint64x1_t)vdup_lane_u32(vget_low_u32((uint32x4_t)b.v.v), 0))))))));
		}

		template<> EIGEN_STRONG_INLINE Packet1cdf pand <Packet1cdf>(const Packet1cdf& a, const Packet1cdf& b)
		{ return Packet1cdf(vandq_u32(a.v.v, b.v.v)); }
		{ return Packet1cdf((float32x4_t)vandq_u32((uint32x4_t)a.v.v, (uint32x4_t)b.v.v)); }
		template<> EIGEN_STRONG_INLINE Packet1cdf por <Packet1cdf>(const Packet1cdf& a, const Packet1cdf& b)
		{ return Packet1cdf(vorrq_u32(a.v.v, b.v.v)); }
		{ return Packet1cdf((float32x4_t)vorrq_u32((uint32x4_t)a.v.v, (uint32x4_t)b.v.v)); }
		template<> EIGEN_STRONG_INLINE Packet1cdf pxor <Packet1cdf>(const Packet1cdf& a, const Packet1cdf& b)
		{ return Packet1cdf(veorq_u32(a.v.v, b.v.v)); }
		{ return Packet1cdf((float32x4_t)veorq_u32((uint32x4_t)a.v.v, (uint32x4_t)b.v.v)); }
		template<> EIGEN_STRONG_INLINE Packet1cdf pandnot<Packet1cdf>(const Packet1cdf& a, const Packet1cdf& b)
		{ return Packet1cdf(vbicq_s32(b.v.v, a.v.v)); }
		{ return Packet1cdf((float32x4_t)vbicq_s32((int32x4_t)b.v.v, (int32x4_t)a.v.v)); }

		template<> EIGEN_STRONG_INLINE Packet1cdf pload <Packet1cdf>(const std::complex<duals::dual<float> >* from)
		{ EIGEN_DEBUG_ALIGNED_LOAD return Packet1cdf(ploadu<Packet4f>((const float*)from)); }
		@@ -217,8 +217,8 @@ template<> EIGEN_STRONG_INLINE Packet1cdf pdiv<Packet1cdf>(const Packet1cdf& a,

		EIGEN_STRONG_INLINE Packet1cdf pcplxflip/* <Packet1cdf> */(const Packet1cdf& x)
		{
		return Packet1cdf(vcombine_u64(vget_high_u64(x.v.v),
		vget_low_u64(x.v.v)));
		return Packet1cdf((float32x4_t)vcombine_u64(vget_high_u64((uint64x2_t)x.v.v),
		vget_low_u64((uint64x2_t)x.v.v)));
		//vec4f_swizzle1(x.v.v, 2, 3, 0, 1));
		}

duals/arch/NEON/Dual.h

+9 −9

Original line number	Diff line number	Diff line
		@@ -262,7 +262,7 @@ template<> EIGEN_STRONG_INLINE Packet2df pdiv<Packet2df>(const Packet2df& a, con
		vaddq_f32(vreinterpretq_f32_u32(vandq_u32(mask,
		vreinterpretq_u32_f32(b.v))),
		vreinterpretq_f32_u32(vandq_u32(vmvnq_u32(mask),
		vreinterpretq_f32_u32(vmulq_f32(c, c)))))));
		vreinterpretq_u32_f32(vmulq_f32(c, c)))))));
		}

		EIGEN_DEVICE_FUNC inline void
		@@ -445,16 +445,16 @@ template<> EIGEN_STRONG_INLINE Packet1dd pdiv<Packet1dd>(const Packet1dd& a, con
		const uint64x2_t mask = {0xffffffffffffffff, 0};
		const uint64x2_t imask = {0, 0xffffffffffffffff};
		return Packet1dd(vdivq_f64
		(vaddq_f64(vandq_u64(mask, a.v),
		vandq_u64(imask,
		vsubq_f64(vmulq_f64(a.v,
		(vaddq_f64(vreinterpretq_f64_u64(vandq_u64(mask, vreinterpretq_u64_f64(a.v))),
		vreinterpretq_f64_u64(vandq_u64(imask,
		vreinterpretq_u64_f64(vsubq_f64(vmulq_f64(a.v,
		vdupq_lane_f64(vget_low_f64(b.v), 0)),
		vmulq_f64(vdupq_lane_f64(vget_low_f64(a.v), 0),
		b.v)))),
		vaddq_f64(vandq_u64(mask, b.v),
		vandq_u64(imask,
		vmulq_f64(vdupq_lane_f64(vget_low_f64(b.v), 0),
		vdupq_lane_f64(vget_low_f64(b.v), 0))))));
		b.v)))))),
		vaddq_f64(vreinterpretq_f64_u64(vandq_u64(mask, vreinterpretq_u64_f64(b.v))),
		vreinterpretq_f64_u64(vandq_u64(imask,
		vreinterpretq_u64_f64(vmulq_f64(vdupq_lane_f64(vget_low_f64(b.v), 0),
		vdupq_lane_f64(vget_low_f64(b.v), 0))))))));
		}

		EIGEN_STRONG_INLINE Packet1dd pcplxflip/<Packet1dd>/(const Packet1dd& x)

tests/CMakeLists.txt

+2 −8

Original line number	Diff line number	Diff line
		@@ -105,12 +105,6 @@ if (CPPDUALS_BENCHMARK)
		# Benchmarks
		#

		message ("searching: ${DEPS_ROOT} for google benchmark libs")
		find_library (BENCHMARK_LIBRARY benchmark PATHS ${DEPS_ROOT}/lib)
		find_library (BENCHMARKM_LIBRARY benchmark_main PATHS ${DEPS_ROOT}/lib)
		#find_library (PTHREAD_LIBRARY pthread)
		message ("BENCHMARK_LIBRARY: ${BENCHMARK_LIBRARY}")
		include_directories ("${BENCHMARK_INC_DIR}")
		if (Boost_FOUND AND NO)
		add_definitions (-DHAVE_BOOST=1)
		include_directories ("${Boost_INCLUDE_DIRS}")
		@@ -225,8 +219,8 @@ if (CPPDUALS_BENCHMARK)
		#target_link_options (${BENCH} PUBLIC ${OPT_FLAGS})
		string (REPLACE ";" ", " L2 "${OPT_FLAGS} ${CMAKE_CXX_FLAGS}")
		target_compile_definitions (${BENCHE} PRIVATE "OPT_FLAGS=${L2}")
		add_dependencies (${BENCHE} benchmarkX eigenX expokitX)
		target_link_libraries (${BENCHE} ${BENCHMARK_LIBRARY} -lpthread ${BLAS_LIBRARIES})
		add_dependencies (${BENCHE} eigenX expokitX)
		target_link_libraries (${BENCHE} benchmark::benchmark ${BLAS_LIBRARIES})
		endforeach ()
		endforeach ()