Performance:OpenCV:BoofCV - Revision history

Peter: /* Conclusions */

2019-05-18T21:59:23Z

Conclusions

← Older revision		Revision as of 21:59, 18 May 2019
Line 129:		Line 129:
	Two computer vision libraries, BoofCV and OpenCV, were compared against each other for speed using a small subset of commonly used computer vision operations. BoofCV was the top performer in 6 out of 10, there was a tie in 2 operations, and OpenCV did best in 2 operations. Tests were performed on desktop and embedded platforms with similar results across the board. Both libraries were given the same input and turned to produce similar output.		Two computer vision libraries, BoofCV and OpenCV, were compared against each other for speed using a small subset of commonly used computer vision operations. BoofCV was the top performer in 6 out of 10, there was a tie in 2 operations, and OpenCV did best in 2 operations. Tests were performed on desktop and embedded platforms with similar results across the board. Both libraries were given the same input and turned to produce similar output.

	Explaining the reason for the differences is difficult due the two libraries having very different architectures. For low level array heavy operations OpenCV has a higher theoretical performance limit than BoofCV due to its ability to include code tailored to specific architectures and GCC generating more effective SIMD instructions than the JVM. As is often the case, due to level of effort, it appears that OpenCV only came close to achieving this theoretical performance with Gaussian blur and not the other operations tested. BoofCV out performed OpenCV in other low level operations and this can sometimes be explained by BoofCV having better concurrent coverage (i.e. comparable single thread performance) and/or a more efficient implementations (i.e. better single thread performance). For high level operations data structures tend to be sparse, partially negating the SIMD performance advantage of a C/C++ implementation~~. Thus, for many high level operations, efficient data structures and algorithms matter more~~.		Explaining the reason for the differences is difficult due the two libraries having very different architectures. For low level array heavy operations OpenCV has a higher theoretical performance limit than BoofCV due to its ability to include code tailored to specific architectures and GCC generating more effective SIMD instructions than the JVM. As is often the case, due to level of effort, it appears that OpenCV only came close to achieving this theoretical performance with Gaussian blur and not the other operations tested. BoofCV out performed OpenCV in other low level operations and this can sometimes be explained by BoofCV having better concurrent coverage (i.e. comparable single thread performance) and/or a more efficient implementations (i.e. better single thread performance). For high level operations data structures tend to be sparse, partially negating the SIMD performance advantage of a C/C++ implementation.

Peter: /* Conclusions */

2019-05-18T21:57:01Z

Conclusions

← Older revision		Revision as of 21:57, 18 May 2019
Line 127:		Line 127:
	= Conclusions =		= Conclusions =

	~~In this benchmark~~, BoofCV was the top performer in 6 out of 10, there was a tie in 2 operations, and OpenCV did best in 2 operations. For low level array heavy operations OpenCV has a higher theoretical performance limit than BoofCV due to its ability to include code tailored to specific architectures and GCC generating more effective SIMD instructions than the JVM. As is often the case, due to level of effort, it appears that OpenCV only came close to achieving this theoretical performance with Gaussian blur and not the other operations tested. BoofCV out performed OpenCV in other low level operations and this can sometimes be explained by BoofCV having better concurrent coverage (i.e. comparable single thread performance) and/or a more efficient implementations (i.e. better single thread performance). For high level operations data structures tend to be sparse, partially negating the SIMD performance advantage of a C/C++ implementation. Thus, for many high level operations, efficient data structures and algorithms matter more~~, as can be seen by BoofCV's performance in operations such as SURF and outer contour~~.		Two computer vision libraries, BoofCV and OpenCV, were compared against each other for speed using a small subset of commonly used computer vision operations. BoofCV was the top performer in 6 out of 10, there was a tie in 2 operations, and OpenCV did best in 2 operations. Tests were performed on desktop and embedded platforms with similar results across the board. Both libraries were given the same input and turned to produce similar output.

			Explaining the reason for the differences is difficult due the two libraries having very different architectures. For low level array heavy operations OpenCV has a higher theoretical performance limit than BoofCV due to its ability to include code tailored to specific architectures and GCC generating more effective SIMD instructions than the JVM. As is often the case, due to level of effort, it appears that OpenCV only came close to achieving this theoretical performance with Gaussian blur and not the other operations tested. BoofCV out performed OpenCV in other low level operations and this can sometimes be explained by BoofCV having better concurrent coverage (i.e. comparable single thread performance) and/or a more efficient implementations (i.e. better single thread performance). For high level operations data structures tend to be sparse, partially negating the SIMD performance advantage of a C/C++ implementation. Thus, for many high level operations, efficient data structures and algorithms matter more.

Peter: /* Exceptions to the Rules */

2019-05-18T21:45:34Z

Exceptions to the Rules

← Older revision		Revision as of 21:45, 18 May 2019
Line 80:		Line 80:
	== Exceptions to the Rules ==		== Exceptions to the Rules ==

	SIFT and SURF are covered by patents (~~or were, SIFT’s just expired this month~~) and not included in the pip package. That means you need to build OpenCV from scratch. Thus, on Desktop, ~~those two operations were~~ running code custom built for my architecture breaking the "average user" rule. Major issues were found on ARM architectures where there was no version of OpenCV 4 that could be easily installed and for BoofCV, the default JVM included ~~lack~~ optimizations for ARM making it run very slow!		SIFT and SURF are covered by patents (SIFT's parent expires in 2020) and not included in the pip package. That means you need to build OpenCV from scratch. Thus, on Desktop, SIFT and SURF are running code custom built for the desktop's architecture breaking the "average user" rule. Major issues were found on ARM architectures where there was no version of OpenCV 4 that could be easily installed and for BoofCV, the default JVM included lacked optimizations for ARM making it run very slow!

	The build settings for OpenCV on ARM are included below. An attempt was made to find the best settings and different websites had different recommendations. I picked one which explicitly enabled CPU specific optimizations.		The build settings for OpenCV on ARM are included below. An attempt was made to find the best settings and different websites had different recommendations. I picked one which explicitly enabled CPU specific optimizations.

Peter: /* Conclusions */

2019-05-15T00:02:31Z

Conclusions

← Older revision		Revision as of 00:02, 15 May 2019
Line 127:		Line 127:
	= Conclusions =		= Conclusions =

	In this benchmark, BoofCV was the top performer in 6 out of 10, there was a tie in 2 operations, and OpenCV did best in 2 operations. For low level array heavy operations OpenCV has a higher theoretical performance limit than BoofCV due to its ability to include code tailored to specific architectures and GCC generating more effective SIMD instructions than the JVM. As is often the case, due to level of effort, it appears that OpenCV only came close to achieving this theoretical performance with Gaussian blur and not the other operations tested. BoofCV out performed OpenCV in other low level operations and this can sometimes be explained by BoofCV having better concurrent coverage (i.e. comparable single thread performance) and/or a more efficient implementations (i.e. better single thread performance). For high level operations data structures tend to be sparse, partially negating the SIMD performance advantage of a C/C++ implementation. Thus, for many high level operations, efficient data structures and algorithms matter more, as can be seen by BoofCV's SURF and outer contour.		In this benchmark, BoofCV was the top performer in 6 out of 10, there was a tie in 2 operations, and OpenCV did best in 2 operations. For low level array heavy operations OpenCV has a higher theoretical performance limit than BoofCV due to its ability to include code tailored to specific architectures and GCC generating more effective SIMD instructions than the JVM. As is often the case, due to level of effort, it appears that OpenCV only came close to achieving this theoretical performance with Gaussian blur and not the other operations tested. BoofCV out performed OpenCV in other low level operations and this can sometimes be explained by BoofCV having better concurrent coverage (i.e. comparable single thread performance) and/or a more efficient implementations (i.e. better single thread performance). For high level operations data structures tend to be sparse, partially negating the SIMD performance advantage of a C/C++ implementation. Thus, for many high level operations, efficient data structures and algorithms matter more, as can be seen by BoofCV's performance in operations such as SURF and outer contour.

Peter at 02:59, 14 May 2019

2019-05-14T02:59:02Z

← Older revision		Revision as of 02:59, 14 May 2019
Line 107:		Line 107:

	For high level operations, implementation details matter more and data structures tend to be sparse, partially negating the compiler advantage of OpenCV. Algorithms are also more complex making explaining performance differences much more difficult. This can be most clearly seen with SURF, where BoofCV was 4x faster and produced more stable features. The main surprise is SIFT, which should have crushed BoofCV because the most computationally expensive part is applying Gaussian blur many times. OpenCV has a large algorithmic advantage with Canny because BoofCV requires Gaussian blur while OpenCV does not. Both BoofCV and OpenCV lack concurrent implementations of outer contour tracing and the most probable explanation is that BoofCV's algorithm is simply faster. The same applies to hough polar.		For high level operations, implementation details matter more and data structures tend to be sparse, partially negating the compiler advantage of OpenCV. Algorithms are also more complex making explaining performance differences much more difficult. This can be most clearly seen with SURF, where BoofCV was 4x faster and produced more stable features. The main surprise is SIFT, which should have crushed BoofCV because the most computationally expensive part is applying Gaussian blur many times. OpenCV has a large algorithmic advantage with Canny because BoofCV requires Gaussian blur while OpenCV does not. Both BoofCV and OpenCV lack concurrent implementations of outer contour tracing and the most probable explanation is that BoofCV's algorithm is simply faster. The same applies to hough polar.

			To help illustrate the points above, here is a table showing single thread performance for select operations on the desktop Core i7 computer. Note how in some cases relative performance changes and in other not. It's rare for users to turn off threading which is why single thread performance isn't discussed in more detail.

			<center>
			{\| class=wikitable
			\|+ Single thread performance on Desktop i7 for select operations. Milliseconds
			! Operation \|\| BoofCV \|\| OpenCV
			\|-
			\| Gaussian Blur \|\| 144 \|\| 74
			\|-
			\| Mean Threshold \|\| 78 \|\| 16
			\|-
			\| Good Features \|\| 172 \|\| 282
			\|-
			\| Outer Contour \|\| 47 \|\| 85
			\|}
			</center>

	= Conclusions =		= Conclusions =

	In this benchmark, BoofCV was the top performer in 6 out of 10, there was a tie in 2 operations, and OpenCV did best in 2 operations. For low level array heavy operations OpenCV has a higher theoretical performance limit than BoofCV due to its ability to include code tailored to specific architectures and GCC generating more effective SIMD instructions than the JVM. As is often the case, due to level of effort, it appears that OpenCV only came close to achieving this theoretical performance with Gaussian blur and not the other operations tested. BoofCV out performed OpenCV in other low level operations and this can sometimes be explained by BoofCV having better concurrent coverage and/or a more efficient implementations. For high level operations data structures tend to be sparse, partially negating the SIMD performance advantage of a C/C++ implementation. Thus, for many high level operations, efficient data structures and algorithms matter more, as can be seen by BoofCV's SURF and outer contour.		In this benchmark, BoofCV was the top performer in 6 out of 10, there was a tie in 2 operations, and OpenCV did best in 2 operations. For low level array heavy operations OpenCV has a higher theoretical performance limit than BoofCV due to its ability to include code tailored to specific architectures and GCC generating more effective SIMD instructions than the JVM. As is often the case, due to level of effort, it appears that OpenCV only came close to achieving this theoretical performance with Gaussian blur and not the other operations tested. BoofCV out performed OpenCV in other low level operations and this can sometimes be explained by BoofCV having better concurrent coverage (i.e. comparable single thread performance) and/or a more efficient implementations (i.e. better single thread performance). For high level operations data structures tend to be sparse, partially negating the SIMD performance advantage of a C/C++ implementation. Thus, for many high level operations, efficient data structures and algorithms matter more, as can be seen by BoofCV's SURF and outer contour.

Peter: /* Conclusions */

2019-05-14T02:38:47Z

Conclusions

← Older revision		Revision as of 02:38, 14 May 2019
Line 110:		Line 110:
	= Conclusions =		= Conclusions =

	In this benchmark, BoofCV was the top performer in 6 out of 10, there was a tie in 2 operations, and OpenCV did best in 2 operations. For low level array heavy operations OpenCV has a higher theoretical performance limit than BoofCV due to its ability to include code tailored to specific architectures. It appears that OpenCV only came close to achieving this theoretical performance with Gaussian blur. ~~BoodCV~~ out performed OpenCV in other low level operations ~~with the likely explanation for~~ this ~~being the lack of refinement in OpenCV's code and~~ sometimes BoofCV having a ~~concurrent implementation~~. For high level operations data structures tend to be sparse, partially negating the SIMD performance advantage of a C/C++ implementation. Thus, for many high level operations, efficient data structures and algorithms matter more, as can be seen by BoofCV's SURF and outer contour ~~implementations~~.		In this benchmark, BoofCV was the top performer in 6 out of 10, there was a tie in 2 operations, and OpenCV did best in 2 operations. For low level array heavy operations OpenCV has a higher theoretical performance limit than BoofCV due to its ability to include code tailored to specific architectures and GCC generating more effective SIMD instructions than the JVM. As is often the case, due to level of effort, it appears that OpenCV only came close to achieving this theoretical performance with Gaussian blur and not the other operations tested. BoofCV out performed OpenCV in other low level operations and this can sometimes be explained by BoofCV having better concurrent coverage and/or a more efficient implementations. For high level operations data structures tend to be sparse, partially negating the SIMD performance advantage of a C/C++ implementation. Thus, for many high level operations, efficient data structures and algorithms matter more, as can be seen by BoofCV's SURF and outer contour.

Peter at 01:38, 14 May 2019

2019-05-14T01:38:56Z

← Older revision		Revision as of 01:38, 14 May 2019
Line 106:		Line 106:
	For low level image processing routines there is less room for implementation variability and results are easier to explain. If OpenCV was optimized to the greatest extent possible, it should output perform BoofCV in low level operations which are array heavy by about 2x to 4x, based on past experience. This is because hand crafted architecture specific code or GCC will typically generate more efficient SIMD instructions than JVM. In practice code is rarely optimized to this extent as is shown by OpenCV. An example of what this level of optimization can achieve is seen with Gaussian blur where OpenCV has hand crafted SIMD instructions and a concurrent implementation and runs 3x faster than BoofCV's own concurrent implementation. Despite all of OpenCV's apparent advantages BoofCV out performs OpenCV's Sobel, histogram, mean threshold implementations is due to a mixture of this code lacking the refinement of Gaussian blur and BoofCV's code being concurrent. It's worth noting that both libraries have spotty concurrent coverage. BoofCV's dominating performance for "good features" was unexpected is likely caused by a superior implementation in combination with BoofCV's code being concurrent.		For low level image processing routines there is less room for implementation variability and results are easier to explain. If OpenCV was optimized to the greatest extent possible, it should output perform BoofCV in low level operations which are array heavy by about 2x to 4x, based on past experience. This is because hand crafted architecture specific code or GCC will typically generate more efficient SIMD instructions than JVM. In practice code is rarely optimized to this extent as is shown by OpenCV. An example of what this level of optimization can achieve is seen with Gaussian blur where OpenCV has hand crafted SIMD instructions and a concurrent implementation and runs 3x faster than BoofCV's own concurrent implementation. Despite all of OpenCV's apparent advantages BoofCV out performs OpenCV's Sobel, histogram, mean threshold implementations is due to a mixture of this code lacking the refinement of Gaussian blur and BoofCV's code being concurrent. It's worth noting that both libraries have spotty concurrent coverage. BoofCV's dominating performance for "good features" was unexpected is likely caused by a superior implementation in combination with BoofCV's code being concurrent.

	For high level operations, implementation details matter more and data structures tend to be sparse, partially negating the compiler advantage of OpenCV. This can be most clearly seen with SURF, where BoofCV was 4x faster and produced more stable features. The main surprise is SIFT, which should have crushed BoofCV because the most computationally expensive part is applying Gaussian blur many times. OpenCV has a large algorithmic advantage with Canny because BoofCV requires Gaussian blur while OpenCV does not. Both BoofCV and OpenCV lack concurrent implementations of ~~external~~ contour tracing and the most probable explanation is that BoofCV's algorithm is simply faster. The same applies to hough polar.		For high level operations, implementation details matter more and data structures tend to be sparse, partially negating the compiler advantage of OpenCV. Algorithms are also more complex making explaining performance differences much more difficult. This can be most clearly seen with SURF, where BoofCV was 4x faster and produced more stable features. The main surprise is SIFT, which should have crushed BoofCV because the most computationally expensive part is applying Gaussian blur many times. OpenCV has a large algorithmic advantage with Canny because BoofCV requires Gaussian blur while OpenCV does not. Both BoofCV and OpenCV lack concurrent implementations of outer contour tracing and the most probable explanation is that BoofCV's algorithm is simply faster. The same applies to hough polar.

	= Conclusions =		= Conclusions =

	In this benchmark, BoofCV was the top performer in 6 out of 10, there was a tie in 2 operations, and OpenCV did best in 2 operations. For low level array heavy operations OpenCV has a higher theoretical performance limit than BoofCV due to its ability to include code tailored to specific architectures. It appears that OpenCV only came close to achieving this theoretical performance with Gaussian blur. BoodCV out performed OpenCV in other low level operations with the likely explanation for this being the lack of refinement in OpenCV's code and sometimes BoofCV having a concurrent implementation. For high level operations data structures tend to be sparse, partially negating the SIMD performance advantage of a C/C++ implementation. Thus, for many high level operations, efficient data structures and algorithms matter more, as can be seen by BoofCV's SURF and ~~external~~ contour implementations.		In this benchmark, BoofCV was the top performer in 6 out of 10, there was a tie in 2 operations, and OpenCV did best in 2 operations. For low level array heavy operations OpenCV has a higher theoretical performance limit than BoofCV due to its ability to include code tailored to specific architectures. It appears that OpenCV only came close to achieving this theoretical performance with Gaussian blur. BoodCV out performed OpenCV in other low level operations with the likely explanation for this being the lack of refinement in OpenCV's code and sometimes BoofCV having a concurrent implementation. For high level operations data structures tend to be sparse, partially negating the SIMD performance advantage of a C/C++ implementation. Thus, for many high level operations, efficient data structures and algorithms matter more, as can be seen by BoofCV's SURF and outer contour implementations.

Peter: /* Conclusions */

2019-05-14T01:34:01Z

Conclusions

← Older revision		Revision as of 01:34, 14 May 2019
Line 110:		Line 110:
	= Conclusions =		= Conclusions =

	In this benchmark, BoofCV was the top performer in 6 out of 10, there was a tie in 2 operations, and OpenCV did best in 2 operations. For low level array heavy operations OpenCV has a higher theoretical performance limit than BoofCV due to its ability to include code tailored to specific architectures. It appears that OpenCV only came close to achieving this theoretical performance with Gaussian blur. BoodCV out performed OpenCV in other low level operations with the likely explanation for this being the lack of refinement in OpenCV's code and sometimes BoofCV having a concurrent implementation. For high level operations data structures tend to be sparse, partially negating the SIMD performance advantage of a C/C++ implementation. ~~In this scenario~~ efficient data structures and algorithms matter more, as can be seen by BoofCV's SURF and external contour implementations.		In this benchmark, BoofCV was the top performer in 6 out of 10, there was a tie in 2 operations, and OpenCV did best in 2 operations. For low level array heavy operations OpenCV has a higher theoretical performance limit than BoofCV due to its ability to include code tailored to specific architectures. It appears that OpenCV only came close to achieving this theoretical performance with Gaussian blur. BoodCV out performed OpenCV in other low level operations with the likely explanation for this being the lack of refinement in OpenCV's code and sometimes BoofCV having a concurrent implementation. For high level operations data structures tend to be sparse, partially negating the SIMD performance advantage of a C/C++ implementation. Thus, for many high level operations, efficient data structures and algorithms matter more, as can be seen by BoofCV's SURF and external contour implementations.

Peter at 01:31, 14 May 2019

2019-05-14T01:31:52Z

← Older revision		Revision as of 01:31, 14 May 2019
Line 95:		Line 95:

	Results are shown below for Intel Core i7, Odroid XU4, and Raspberry PI 3B+. Click on the arrow to change which results you are viewing.		Results are shown below for Intel Core i7, Odroid XU4, and Raspberry PI 3B+. Click on the arrow to change which results you are viewing.

	OpenCV does very well in the Gaussian Blur test due to its hand crafted SIMD instructions being multi-threaded. For other low level SIMD friendly operations the speed difference isn't as great between Java and the C code (GCC does a better job optimizing for SIMD than JVM), so it tends to come down to threading performance. SURF doesn't lend itself towards SIMD optimization, meaning that the compiler is less important and algorithm more important. The main surprise is SIFT, which should have crushed BoofCV because the most computationally expensive part is applying Gaussian blur many times.

	Results between architectures are more consistent than it was thought they would be. OpenCV on desktop used the generic version contained in pypy (except for SIFT and SURF) while OpenCV for ARM architectures had been custom built for each architecture. Winners and near ties are effectively the same. OpenCV's SIFT was unable to finish computing on ARM processors, threw out of memory error or just died. OpenCV's SIFT code has not been inspect to root cause this problem, but BoofCV's implementation was designed to recycle images as much as possible.

	<gallery mode="slideshow">		<gallery mode="slideshow">
Line 105:		Line 101:
	File:Boof_vs_opencv_rpi3BP_2019.png		File:Boof_vs_opencv_rpi3BP_2019.png
	</gallery>		</gallery>

			Results between architectures are more consistent than it was thought they would be. OpenCV on desktop used the generic version contained in pypy (except for SIFT and SURF) while OpenCV for ARM architectures had been custom built for each architecture. Winners and near ties are effectively the same. OpenCV's SIFT was unable to finish computing on ARM processors, threw out of memory error or just died. OpenCV's SIFT code has not been inspect to root cause this problem, but BoofCV's implementation was designed to recycle images as much as possible.

			For low level image processing routines there is less room for implementation variability and results are easier to explain. If OpenCV was optimized to the greatest extent possible, it should output perform BoofCV in low level operations which are array heavy by about 2x to 4x, based on past experience. This is because hand crafted architecture specific code or GCC will typically generate more efficient SIMD instructions than JVM. In practice code is rarely optimized to this extent as is shown by OpenCV. An example of what this level of optimization can achieve is seen with Gaussian blur where OpenCV has hand crafted SIMD instructions and a concurrent implementation and runs 3x faster than BoofCV's own concurrent implementation. Despite all of OpenCV's apparent advantages BoofCV out performs OpenCV's Sobel, histogram, mean threshold implementations is due to a mixture of this code lacking the refinement of Gaussian blur and BoofCV's code being concurrent. It's worth noting that both libraries have spotty concurrent coverage. BoofCV's dominating performance for "good features" was unexpected is likely caused by a superior implementation in combination with BoofCV's code being concurrent.

			For high level operations, implementation details matter more and data structures tend to be sparse, partially negating the compiler advantage of OpenCV. This can be most clearly seen with SURF, where BoofCV was 4x faster and produced more stable features. The main surprise is SIFT, which should have crushed BoofCV because the most computationally expensive part is applying Gaussian blur many times. OpenCV has a large algorithmic advantage with Canny because BoofCV requires Gaussian blur while OpenCV does not. Both BoofCV and OpenCV lack concurrent implementations of external contour tracing and the most probable explanation is that BoofCV's algorithm is simply faster. The same applies to hough polar.

	= Conclusions =		= Conclusions =

	In this benchmark, BoofCV was the top performer in 6 out of 10, there was a tie in 2 operations, and OpenCV did best in 2 operations. ~~This means on average~~ BoofCV ~~was the top overall performer~~. OpenCV ~~typically does well~~ in low level ~~SIMD friendly operation (e.g. convolutions) due to superior optimization by GCC and in some cases, hand written SIMD instructions~~ with ~~concurrent code. Both OpenCV and BoofCV have spotty support~~ for ~~concurrency. In~~ the ~~case~~ of ~~Sobel, BoofCV now outperforms OpenCV, even though~~ OpenCV ~~has many advantages, due to BoofCV~~'s implementation ~~being concurrent~~. For high level ~~algorithms, which are not dominated by SIMD friendly~~ operations, ~~BoofCV does very well and~~ the ~~likely explanation for better~~ performance ~~is more~~ efficient algorithms.		In this benchmark, BoofCV was the top performer in 6 out of 10, there was a tie in 2 operations, and OpenCV did best in 2 operations. For low level array heavy operations OpenCV has a higher theoretical performance limit than BoofCV due to its ability to include code tailored to specific architectures. It appears that OpenCV only came close to achieving this theoretical performance with Gaussian blur. BoodCV out performed OpenCV in other low level operations with the likely explanation for this being the lack of refinement in OpenCV's code and sometimes BoofCV having a concurrent implementation. For high level operations data structures tend to be sparse, partially negating the SIMD performance advantage of a C/C++ implementation. In this scenario efficient data structures and algorithms matter more, as can be seen by BoofCV's SURF and external contour implementations.

Peter: /* Conclusions */

2019-05-12T21:07:33Z

Conclusions

← Older revision		Revision as of 21:07, 12 May 2019
Line 108:		Line 108:
	= Conclusions =		= Conclusions =

	In ~~the operations tested in~~ this benchmark, BoofCV was the top performer in 6 out of 10, there was a tie in 2 operations, and OpenCV did best in 2 operations. This means on average BoofCV was the top overall performer. OpenCV typically does well in low level SIMD friendly operation (e.g. convolutions) due to superior optimization by GCC and in some cases, hand written SIMD instructions with concurrent ~~implementations~~. Both OpenCV and BoofCV have spotty support for concurrency. In the case of Sobel, BoofCV now outperforms OpenCV, even though OpenCV has many advantages, due to BoofCV's implementation being concurrent. For high level algorithms, which are not dominated by SIMD friendly operations, BoofCV does very well and the likely explanation for better performance is more efficient algorithms.		In this benchmark, BoofCV was the top performer in 6 out of 10, there was a tie in 2 operations, and OpenCV did best in 2 operations. This means on average BoofCV was the top overall performer. OpenCV typically does well in low level SIMD friendly operation (e.g. convolutions) due to superior optimization by GCC and in some cases, hand written SIMD instructions with concurrent code. Both OpenCV and BoofCV have spotty support for concurrency. In the case of Sobel, BoofCV now outperforms OpenCV, even though OpenCV has many advantages, due to BoofCV's implementation being concurrent. For high level algorithms, which are not dominated by SIMD friendly operations, BoofCV does very well and the likely explanation for better performance is more efficient algorithms.