From c8be98bfd373a2fcad03eb0cb9a7e3b26bade3f8 Mon Sep 17 00:00:00 2001 From: David Allemang Date: Mon, 16 Sep 2024 17:36:04 -0400 Subject: [PATCH] ENH: Bandwidth-based benchmark --- ...maBenchmark.cxx => BandwidthBenchmark.cxx} | 131 +++++----- examples/CMakeLists.txt | 7 +- examples/ResolutionBenchmark.cxx | 228 ------------------ examples/bandwidth-benchmark.csv | 131 ++++++++++ examples/plots.ipynb | 89 +++---- examples/resolution-benchmark.csv | 106 -------- examples/sigma-benchmark.csv | 71 ------ 7 files changed, 227 insertions(+), 536 deletions(-) rename examples/{SigmaBenchmark.cxx => BandwidthBenchmark.cxx} (68%) delete mode 100644 examples/ResolutionBenchmark.cxx create mode 100644 examples/bandwidth-benchmark.csv delete mode 100644 examples/resolution-benchmark.csv delete mode 100644 examples/sigma-benchmark.csv diff --git a/examples/SigmaBenchmark.cxx b/examples/BandwidthBenchmark.cxx similarity index 68% rename from examples/SigmaBenchmark.cxx rename to examples/BandwidthBenchmark.cxx index 17c575c..3bbd472 100644 --- a/examples/SigmaBenchmark.cxx +++ b/examples/BandwidthBenchmark.cxx @@ -18,6 +18,7 @@ #include "itkHalideDiscreteGaussianImageFilter.h" #include "itkDiscreteGaussianImageFilter.h" +#include "itkRecursiveGaussianImageFilter.h" #include "itkHalideGPUDiscreteGaussianImageFilter.h" #include "itkGPUDiscreteGaussianImageFilter.h" #include "itkAdditiveGaussianNoiseImageFilter.h" @@ -39,25 +40,40 @@ using HalideBlur = itk::HalideDiscreteGaussianImageFilter; using GPUBlur = itk::GPUDiscreteGaussianImageFilter; using HalideGPUBlur = itk::HalideGPUDiscreteGaussianImageFilter; -using ms = std::chrono::duration; +using ns = std::chrono::duration; -ms +ns run_itk_cpu(ImageType * image, float sigma) { using FilterType = itk::DiscreteGaussianImageFilter; FilterType::Pointer filter = FilterType::New(); filter->SetInput(image); - filter->SetVariance(sigma * sigma); + filter->SetSigma(sigma); filter->SetMaximumKernelWidth(48); std::chrono::high_resolution_clock::time_point start = std::chrono::high_resolution_clock::now(); filter->Update(); std::chrono::high_resolution_clock::time_point end = std::chrono::high_resolution_clock::now(); - return std::chrono::duration_cast(end - start); + return std::chrono::duration_cast(end - start); } -ms +ns +run_itk_rec(ImageType * image, float sigma) +{ + using FilterType = itk::RecursiveGaussianImageFilter; + FilterType::Pointer filter = FilterType::New(); + filter->SetInput(image); + filter->SetSigma(sigma); + + std::chrono::high_resolution_clock::time_point start = std::chrono::high_resolution_clock::now(); + filter->Update(); + std::chrono::high_resolution_clock::time_point end = std::chrono::high_resolution_clock::now(); + + return std::chrono::duration_cast(end - start); +} + +ns run_itk_gpu(ImageType * image, float sigma) { using CastType = itk::CastImageFilter; @@ -67,7 +83,7 @@ run_itk_gpu(ImageType * image, float sigma) using FilterType = itk::GPUDiscreteGaussianImageFilter; FilterType::Pointer filter = FilterType::New(); filter->SetInput(cast->GetOutput()); - filter->SetVariance(sigma * sigma); + filter->SetSigma(sigma); filter->SetMaximumKernelWidth(48); std::chrono::high_resolution_clock::time_point start = std::chrono::high_resolution_clock::now(); @@ -76,11 +92,11 @@ run_itk_gpu(ImageType * image, float sigma) filter->GetOutput()->UpdateBuffers(); std::chrono::high_resolution_clock::time_point end = std::chrono::high_resolution_clock::now(); - return std::chrono::duration_cast(end - start); + return std::chrono::duration_cast(end - start); } -ms -run_halide_cpu(ImageType * image, float sigma) +ns +run_hal_cpu(ImageType * image, float sigma) { using FilterType = itk::HalideDiscreteGaussianImageFilter; FilterType::Pointer filter = FilterType::New(); @@ -92,11 +108,11 @@ run_halide_cpu(ImageType * image, float sigma) filter->Update(); std::chrono::high_resolution_clock::time_point end = std::chrono::high_resolution_clock::now(); - return std::chrono::duration_cast(end - start); + return std::chrono::duration_cast(end - start); } -ms -run_halide_gpu(ImageType * image, float sigma) +ns +run_hal_gpu(ImageType * image, float sigma) { using FilterType = itk::HalideGPUDiscreteGaussianImageFilter; FilterType::Pointer filter = FilterType::New(); @@ -108,7 +124,7 @@ run_halide_gpu(ImageType * image, float sigma) filter->Update(); std::chrono::high_resolution_clock::time_point end = std::chrono::high_resolution_clock::now(); - return std::chrono::duration_cast(end - start); + return std::chrono::duration_cast(end - start); } ImageType::Pointer @@ -146,6 +162,22 @@ make_image(float extent, size_t resolution) return noise->GetOutput(); } +size_t +get_kernel_radius(ImageType * image, float sigma) +{ + CPUBlur::Pointer temp = CPUBlur::New(); + temp->SetInput(image); + temp->SetSigma(sigma); + temp->SetMaximumKernelWidth(48); + return temp->GetKernelRadius()[0]; +} + +double +bandwidth(ns time, size_t count) +{ + return count / time.count(); +} + int main(int argc, char * argv[]) { @@ -157,77 +189,46 @@ main(int argc, char * argv[]) std::string out_path(argv[1]); std::ofstream csv(out_path); + size_t samples = 10; - float extent = 300.0; - size_t resolution = 1; + size_t image_width = 500; + size_t byte_count = image_width * image_width * image_width * sizeof(ImageType::PixelType); - ImageType::Pointer image = make_image(extent, resolution); + ImageType::Pointer image = make_image(image_width, 1.0); + // warm-up device context { - // warm-up device context run_itk_cpu(image, 1); + run_itk_rec(image, 1); run_itk_gpu(image, 1); - run_halide_cpu(image, 1); - run_halide_gpu(image, 1); + run_hal_cpu(image, 1); + run_hal_cpu(image, 1); } - size_t samples = 5; + csv << "sigma,radius,itk_cpu,itk_rec,itk_gpu,hal_cpu,hal_gpu" << std::endl; - csv << "sigma,itk_cpu,itk_gpu,itk_halide_cpu,itk_halide_gpu" << std::endl; + for (float sigma = 1; sigma < 20; sigma += 1.5) + { + size_t radius = get_kernel_radius(image, sigma); - const auto proc = [&](float sigma) { - std::cout << "sigma " << sigma << " " << std::flush; + std::cout << "sigma " << sigma << " (radius " << radius << ")" << std::flush; - for (size_t sample = 0; sample < samples; sample++) + for (int k = 0; k < samples; ++k) { std::cout << "." << std::flush; - csv << sigma << ","; - - if (sigma <= 5) // ITK CPU is prohibitively slow past this point - { - csv << run_itk_cpu(image, sigma).count() << ","; - } - else - { - csv << "nan,"; - } - - // if (extent * res < 800) // ITK GPU memory allocation failure past this point - // { - csv << run_itk_gpu(image, sigma).count() << ","; - // } - // else - // { - // csv << "nan,"; - // } - - if (sigma < 19) // Halide CPU is prohibitively slow past this point - { - csv << run_halide_cpu(image, sigma).count() << ","; - } - else - { - csv << "nan,"; - } - - csv << run_halide_gpu(image, sigma).count() << ","; - + csv << sigma << "," << radius << ","; + csv << bandwidth(run_itk_cpu(image, sigma), byte_count) << ","; + csv << bandwidth(run_itk_rec(image, sigma), byte_count) << ","; + csv << bandwidth(run_itk_gpu(image, sigma), byte_count) << ","; + csv << bandwidth(run_hal_cpu(image, sigma), byte_count) << ","; + csv << bandwidth(run_hal_gpu(image, sigma), byte_count); csv << std::endl; } std::cout << std::endl; - }; - - for (int i = 1; i <= 8; i += 1) - { - proc(static_cast(i)); - } - for (int i = 10; i <= 25; i += 3) - { - // beyond 25, kernel is too large. - proc(static_cast(i)); } + return EXIT_SUCCESS; } diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt index 6e317fa..5a974d5 100644 --- a/examples/CMakeLists.txt +++ b/examples/CMakeLists.txt @@ -16,8 +16,5 @@ else() endif() include(${ITK_USE_FILE}) -add_executable(ResolutionBenchmark ResolutionBenchmark.cxx) -target_link_libraries(ResolutionBenchmark ${ITK_LIBRARIES}) - -add_executable(SigmaBenchmark SigmaBenchmark.cxx) -target_link_libraries(SigmaBenchmark ${ITK_LIBRARIES}) +add_executable(BandwidthBenchmark BandwidthBenchmark.cxx) +target_link_libraries(BandwidthBenchmark ${ITK_LIBRARIES}) diff --git a/examples/ResolutionBenchmark.cxx b/examples/ResolutionBenchmark.cxx deleted file mode 100644 index 7ccd721..0000000 --- a/examples/ResolutionBenchmark.cxx +++ /dev/null @@ -1,228 +0,0 @@ -/*========================================================================= - * - * Copyright NumFOCUS - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0.txt - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - *=========================================================================*/ - -#include "itkHalideDiscreteGaussianImageFilter.h" -#include "itkDiscreteGaussianImageFilter.h" -#include "itkHalideGPUDiscreteGaussianImageFilter.h" -#include "itkGPUDiscreteGaussianImageFilter.h" -#include "itkAdditiveGaussianNoiseImageFilter.h" -#include "itkCastImageFilter.h" -#include "itkImage.h" -#include "itkGPUImage.h" - -#include "itkImageFileReader.h" -#include "itkImageFileWriter.h" - -using ImageType = itk::Image; -using NoiseFilter = itk::AdditiveGaussianNoiseImageFilter; -using GPUImageType = itk::GPUImage; -using CastToGPUImage = itk::CastImageFilter; - -using CPUBlur = itk::DiscreteGaussianImageFilter; -using HalideBlur = itk::HalideDiscreteGaussianImageFilter; - -using GPUBlur = itk::GPUDiscreteGaussianImageFilter; -using HalideGPUBlur = itk::HalideGPUDiscreteGaussianImageFilter; - -using ms = std::chrono::duration; - -ms -run_itk_cpu(ImageType * image, float variance) -{ - using FilterType = itk::DiscreteGaussianImageFilter; - FilterType::Pointer filter = FilterType::New(); - filter->SetInput(image); - filter->SetVariance(variance); - - std::chrono::high_resolution_clock::time_point start = std::chrono::high_resolution_clock::now(); - filter->Update(); - std::chrono::high_resolution_clock::time_point end = std::chrono::high_resolution_clock::now(); - - return std::chrono::duration_cast(end - start); -} - -ms -run_itk_gpu(ImageType * image, float variance) -{ - using CastType = itk::CastImageFilter; - CastType::Pointer cast = CastType::New(); - cast->SetInput(image); - - using FilterType = itk::GPUDiscreteGaussianImageFilter; - FilterType::Pointer filter = FilterType::New(); - filter->SetInput(cast->GetOutput()); - filter->SetVariance(variance); - - std::chrono::high_resolution_clock::time_point start = std::chrono::high_resolution_clock::now(); - cast->Update(); - filter->Update(); - filter->GetOutput()->UpdateBuffers(); - std::chrono::high_resolution_clock::time_point end = std::chrono::high_resolution_clock::now(); - - return std::chrono::duration_cast(end - start); -} - -ms -run_halide_cpu(ImageType * image, float variance) -{ - using FilterType = itk::HalideDiscreteGaussianImageFilter; - FilterType::Pointer filter = FilterType::New(); - filter->SetInput(image); - filter->SetVariance(variance); - - std::chrono::high_resolution_clock::time_point start = std::chrono::high_resolution_clock::now(); - filter->Update(); - std::chrono::high_resolution_clock::time_point end = std::chrono::high_resolution_clock::now(); - - return std::chrono::duration_cast(end - start); -} - -ms -run_halide_gpu(ImageType * image, float variance) -{ - using FilterType = itk::HalideGPUDiscreteGaussianImageFilter; - FilterType::Pointer filter = FilterType::New(); - filter->SetInput(image); - filter->SetVariance(variance); - - std::chrono::high_resolution_clock::time_point start = std::chrono::high_resolution_clock::now(); - filter->Update(); - std::chrono::high_resolution_clock::time_point end = std::chrono::high_resolution_clock::now(); - - return std::chrono::duration_cast(end - start); -} - -ImageType::Pointer -make_image(float extent, size_t resolution) -{ - ImageType::Pointer image = ImageType::New(); - - { - ImageType::IndexType index; - index.Fill(0); - - ImageType::SizeType size; - size.Fill(static_cast(extent * static_cast(resolution))); - - ImageType::RegionType region; - region.SetIndex(index); - region.SetSize(size); - - image->SetRegions(region); - - ImageType::SpacingType spacing; - spacing.Fill(1.0 / static_cast(resolution)); - - image->SetSpacing(spacing); - - image->Allocate(); - } - - NoiseFilter::Pointer noise = NoiseFilter::New(); - noise->SetInput(image); - noise->SetMean(0); - noise->SetStandardDeviation(2.0); - noise->Update(); - - return noise->GetOutput(); -} - -int -main(int argc, char * argv[]) -{ - if (argc < 2) - { - std::cerr << "Usage: " << argv[0] << " OUT" << std::endl; - return EXIT_FAILURE; - } - - std::string out_path(argv[1]); - std::ofstream csv(out_path); - - float extent = 10.0; - float variance = 0.5; - - { - // warm-up device context - ImageType::Pointer image = make_image(10, 5); - run_itk_cpu(image, 1); - run_itk_gpu(image, 1); - run_halide_cpu(image, 1); - run_halide_gpu(image, 1); - } - - size_t samples = 5; - - csv << "res,itk_cpu,itk_gpu,itk_halide_cpu,itk_halide_gpu" << std::endl; - - const auto proc = [&](size_t res) { - std::cout << "resolution " << res << " " << std::flush; - - ImageType::Pointer image = make_image(extent, res); - - for (size_t sample = 0; sample < samples; sample++) - { - std::cout << "." << std::flush; - - csv << res << ","; - - if (extent * res < 400) // ITK CPU is prohibitively slow past this point - { - csv << run_itk_cpu(image, variance).count() << ","; - } - else - { - csv << "nan,"; - } - - if (extent * res < 800) // ITK GPU memory allocation failure past this point - { - csv << run_itk_gpu(image, variance).count() << ","; - } - else - { - csv << "nan,"; - } - - csv << run_halide_cpu(image, variance).count() << ","; - - csv << run_halide_gpu(image, variance).count() << ","; - - csv << std::endl; - } - - std::cout << std::endl; - }; - - for (size_t res = 5; res <= 15; res += 2) - { - proc(res); - } - - for (size_t res = 5; res <= 45; res += 10) - { - proc(res); - } - - for (size_t res = 10; res <= 100; res += 10) - { - proc(res); - } - - return EXIT_SUCCESS; -} diff --git a/examples/bandwidth-benchmark.csv b/examples/bandwidth-benchmark.csv new file mode 100644 index 0000000..cef3390 --- /dev/null +++ b/examples/bandwidth-benchmark.csv @@ -0,0 +1,131 @@ +sigma,radius,itk_cpu,itk_rec,itk_gpu,hal_cpu,hal_gpu +1,3,1.61112,7.99631,1.4464,12.9393,2.46999 +1,3,1.46958,7.99276,1.4641,12.9366,2.95072 +1,3,1.57499,8.24819,1.40071,12.7554,2.94708 +1,3,1.22588,8.06163,1.46266,12.8442,2.94219 +1,3,1.3862,8.27666,1.45341,12.9479,2.95528 +1,3,1.34292,8.26069,1.44622,12.825,2.97362 +1,3,1.38685,8.3207,1.46813,13.0337,2.97219 +1,3,1.4133,8.3212,1.43747,13.0742,2.95713 +1,3,1.5578,8.27179,1.46381,12.6985,2.96459 +1,3,1.4752,8.25621,1.45626,13.0361,2.95971 +2.5,7,0.787243,7.95062,1.44988,10.531,2.82672 +2.5,7,0.783839,8.50714,1.4423,10.6074,2.83184 +2.5,7,0.806667,7.10641,1.45853,10.4499,2.83848 +2.5,7,0.778242,7.93893,1.43171,10.5797,2.85061 +2.5,7,0.787667,8.47525,1.4649,10.296,2.83853 +2.5,7,0.794682,8.22743,1.43281,10.5865,2.83938 +2.5,7,0.770505,8.34075,1.42323,10.7311,2.82031 +2.5,7,0.776198,8.26844,1.43737,10.6026,2.84389 +2.5,7,0.767429,8.84602,1.43343,10.521,2.82905 +2.5,7,0.795689,6.65494,1.45205,10.4372,2.85401 +4,10,0.537667,7.0726,1.45051,8.38604,2.76223 +4,10,0.545838,7.97733,1.42165,8.39338,2.74552 +4,10,0.541264,8.39914,1.42092,8.20416,2.74745 +4,10,0.541305,8.3395,1.4287,8.48398,2.7492 +4,10,0.542309,8.27049,1.44684,8.28116,2.74704 +4,10,0.538817,8.25776,1.42422,8.34445,2.74959 +4,10,0.545299,8.4552,1.42714,8.36197,2.7534 +4,10,0.541431,6.91978,1.44974,8.23732,2.74503 +4,10,0.541023,8.23463,1.42081,8.36443,2.74498 +4,10,0.452623,7.81062,1.41852,8.40798,2.74753 +5.5,14,0.356373,8.23624,1.42037,5.27629,2.63156 +5.5,14,0.358068,8.20646,1.43082,5.15719,2.62734 +5.5,14,0.354668,8.1349,1.42775,5.25835,2.63007 +5.5,14,0.354992,8.36883,1.44049,5.16611,2.5945 +5.5,14,0.347537,7.92506,1.43835,5.26868,2.62813 +5.5,14,0.35296,7.85039,1.42009,5.1119,2.64738 +5.5,14,0.352576,8.32968,1.43398,5.1083,2.62955 +5.5,14,0.352654,8.40253,1.40123,5.14887,2.62582 +5.5,14,0.354099,8.19179,1.4381,5.23612,2.65418 +5.5,14,0.352672,7.84073,1.43723,5.22026,2.64763 +7,18,0.267653,8.26554,1.43065,3.51301,2.54249 +7,18,0.267095,7.50241,1.4211,3.5506,2.53431 +7,18,0.263956,8.27601,1.41062,3.49921,2.53737 +7,18,0.26726,7.89572,1.41848,3.49594,2.5261 +7,18,0.267118,8.51513,1.37955,3.39457,2.52017 +7,18,0.265531,7.39517,1.39683,3.47459,2.52364 +7,18,0.260667,7.49873,1.4146,3.46476,2.54295 +7,18,0.267246,8.04451,1.41801,3.39416,2.52523 +7,18,0.264024,8.23715,1.42784,3.40397,2.5276 +7,18,0.262763,7.97213,1.42784,3.46002,2.51202 +8.5,22,0.210346,7.9178,1.40305,2.40517,2.40281 +8.5,22,0.210923,7.86874,1.40975,2.46387,2.42261 +8.5,22,0.208179,8.25152,1.39302,2.45143,2.42296 +8.5,22,0.210628,8.28469,1.41698,2.4804,2.42459 +8.5,22,0.212605,7.86446,1.37151,2.45175,2.42647 +8.5,22,0.210466,7.96758,1.40091,2.39169,2.39876 +8.5,22,0.211237,8.1352,1.38526,2.41658,2.42556 +8.5,22,0.209728,7.89585,1.38693,2.41688,2.4027 +8.5,22,0.21119,7.50996,1.4173,2.45504,2.43313 +8.5,22,0.212697,8.01824,1.3974,2.43431,2.39878 +10,26,0.176086,8.21161,1.39609,1.71695,2.32256 +10,26,0.173986,7.86375,1.39551,1.80679,2.33837 +10,26,0.176118,8.18936,1.40022,1.74617,2.30305 +10,26,0.174739,8.22881,1.38252,1.80658,2.3387 +10,26,0.174557,8.03599,1.36352,1.76842,2.32595 +10,26,0.168306,8.00623,1.36815,1.78418,2.32362 +10,26,0.169536,8.27746,1.39132,1.7853,2.31593 +10,26,0.166927,8.20002,1.39694,1.81398,2.32464 +10,26,0.171007,7.77218,1.40068,1.81191,2.32916 +10,26,0.170305,8.08183,1.39057,1.8151,2.34073 +11.5,30,0.142369,8.197,1.3288,1.37514,2.24174 +11.5,30,0.141631,8.21382,1.38535,1.36665,2.24651 +11.5,30,0.14233,7.89208,1.37468,1.37519,2.25065 +11.5,30,0.14199,8.01261,1.27926,1.29854,2.16785 +11.5,30,0.140188,7.88193,1.38681,1.36925,2.24628 +11.5,30,0.141245,8.09246,1.3863,1.36377,2.25002 +11.5,30,0.141142,7.94195,1.37832,1.36018,2.24048 +11.5,30,0.142026,8.3175,1.35643,1.35808,2.24054 +11.5,30,0.141665,7.97778,1.38303,1.34672,2.23334 +11.5,30,0.142131,7.83471,1.38125,1.3495,2.21601 +13,34,0.122166,8.08311,1.36519,1.08165,2.14966 +13,34,0.12142,7.80318,1.36566,1.07913,2.07625 +13,34,0.122553,8.41118,1.36123,1.07915,2.11672 +13,34,0.120829,7.94403,1.37406,1.02511,2.10841 +13,34,0.122611,8.14362,1.37191,1.098,2.14064 +13,34,0.119791,8.22026,1.32032,1.08163,2.098 +13,34,0.120817,8.19268,1.36393,1.06986,2.15331 +13,34,0.122884,8.16894,1.36692,1.07013,2.14983 +13,34,0.119686,8.1943,1.36927,1.08017,2.15586 +13,34,0.122764,8.12808,1.3553,1.08619,2.11616 +14.5,39,0.103162,7.88871,1.33639,0.832045,2.06033 +14.5,39,0.103119,7.83365,1.31742,0.840545,2.02484 +14.5,39,0.101281,7.87774,1.33404,0.844718,2.04762 +14.5,39,0.102264,8.07625,1.30424,0.838166,2.05403 +14.5,39,0.10354,8.20525,1.33276,0.823061,2.06566 +14.5,39,0.100879,8.4054,1.32268,0.814715,2.04893 +14.5,39,0.101919,8.2543,1.32476,0.833992,2.02303 +14.5,39,0.102004,8.18017,1.3281,0.830785,2.07508 +14.5,39,0.103556,8.14619,1.31744,0.824559,2.05826 +14.5,39,0.102109,8.2533,1.32794,0.824309,2.00645 +16,46,0.0818709,8.14732,1.29026,0.597913,1.92499 +16,46,0.0831804,8.17945,1.28402,0.596219,1.91438 +16,46,0.0821552,7.8805,1.2974,0.59219,1.92159 +16,46,0.0825992,7.77866,1.29382,0.596492,1.91765 +16,46,0.0828311,7.72222,1.29917,0.6009,1.90444 +16,46,0.0817077,7.96786,1.26428,0.588314,1.91697 +16,46,0.0818095,8.07846,1.28392,0.598064,1.93223 +16,46,0.0812776,8.21468,1.28414,0.592618,1.93523 +16,46,0.0807677,8.09938,1.2728,0.588595,1.92407 +16,46,0.0811941,8.30707,1.28351,0.592794,1.92252 +17.5,48,0.0760954,8.15622,1.26079,0.537987,1.88163 +17.5,48,0.0768655,8.12571,1.26738,0.53546,1.8913 +17.5,48,0.0762807,7.9101,1.27296,0.551602,1.87443 +17.5,48,0.0766127,8.36169,1.23692,0.546303,1.88463 +17.5,48,0.0761123,8.1044,1.2742,0.538805,1.89316 +17.5,48,0.0767712,8.14787,1.26821,0.538104,1.89561 +17.5,48,0.0747045,7.74893,1.27113,0.523169,1.88939 +17.5,48,0.0751046,8.15154,1.27804,0.539315,1.89512 +17.5,48,0.076328,7.85847,1.26592,0.538313,1.89516 +17.5,48,0.077137,8.0141,1.23417,0.545115,1.8882 +19,48,0.0752156,8.19573,1.27783,0.542203,1.8791 +19,48,0.076446,8.24103,1.27564,0.543281,1.87087 +19,48,0.0763145,7.89793,1.25349,0.537791,1.90038 +19,48,0.0760021,7.86856,1.26351,0.551787,1.88916 +19,48,0.0752429,8.11224,1.27154,0.540445,1.89484 +19,48,0.0766105,8.61315,1.26334,0.522338,1.89705 +19,48,0.0770264,7.87941,1.25957,0.53952,1.88663 +19,48,0.0754207,8.14474,1.24888,0.52904,1.85074 +19,48,0.0751988,7.4984,1.25992,0.528503,1.84601 +19,48,0.0777388,7.81183,1.25168,0.540942,1.85757 diff --git a/examples/plots.ipynb b/examples/plots.ipynb index ac0960f..2c824e7 100644 --- a/examples/plots.ipynb +++ b/examples/plots.ipynb @@ -10,24 +10,18 @@ "import pandas as pd\n", "import numpy as np\n", "from numpy.polynomial import Polynomial\n", - "import matplotlib.pyplot as plt\n", - "\n", - "def plot_fit_series(series, label, deg=3):\n", - " plt.scatter(series.index, series, label=label, s=9)\n", - " plt.plot(*Polynomial.fit(series.index, series, deg).linspace(), ls='dashed', label='_'+label, lw=1)" + "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": 2, - "id": "4fd2c89b", - "metadata": { - "scrolled": false - }, + "id": "d2227b35", + "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -37,65 +31,38 @@ } ], "source": [ - "res = pd.read_csv('resolution-benchmark.csv', index_col=False)\n", - "res = res.groupby('res').min() # best of 5\n", + "df = pd.read_csv('bandwidth-benchmark.csv', index_col=False)\n", + "df = df.groupby('radius')\n", + "\n", + "def plot(ser, **kw):\n", + " plt.plot(ser.mean().index, ser.mean(), **kw)\n", + " \n", + "plot(df.itk_cpu, label='ITK Discrete')\n", + "plot(df.itk_gpu, label='ITK GPU Discrete')\n", + "plot(df.hal_cpu, label='ITKHalide Discrete', lw=2)\n", + "plot(df.hal_gpu, label='ITKHalide GPU Discrete', lw=2)\n", + "plot(df.itk_rec, label='ITK Recursive', ls='dashed')\n", + "\n", + "plt.suptitle('3D Image Processing Speed')\n", + "plt.title('Average of 10 runs. Higher is better.', fontsize=10)\n", + "\n", + "plt.ylabel('Processing Bandwidth (GB/s)')\n", + "plt.xlabel('Gaussian kernel radius (px)')\n", "\n", - "itk_cpu = res.itk_cpu.dropna()\n", - "itk_gpu = res.itk_gpu.dropna()\n", - "hal_cpu = res.itk_halide_cpu.dropna()\n", - "hal_gpu = res.itk_halide_gpu.dropna()\n", + "plt.legend(loc='upper right')\n", "\n", - "plot_fit_series(itk_cpu, 'ITK CPU')\n", - "plot_fit_series(itk_gpu, 'ITK GPU')\n", - "plot_fit_series(hal_cpu, 'Halide CPU')\n", - "plot_fit_series(hal_gpu, 'Halide GPU')\n", + "plt.grid(True)\n", "\n", - "plt.title(\"10x10x10mm Image; 0.5mm Gaussian Variance.\\n(Best of Five)\")\n", - "plt.xlabel('Image Resolution (px/mm)')\n", - "plt.ylabel('Runtime (ms)')\n", - "_ = plt.legend()" + "None" ] }, { "cell_type": "code", - "execution_count": 3, - "id": "6bd1ecb1", + "execution_count": null, + "id": "83c463cc", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "var = pd.read_csv('sigma-benchmark.csv', index_col=False)\n", - "var = var.groupby('sigma').min() # best of 5\n", - "\n", - "itk_cpu = var.itk_cpu.dropna()\n", - "itk_gpu = var.itk_gpu.dropna()\n", - "hal_cpu = var.itk_halide_cpu.dropna()\n", - "hal_gpu = var.itk_halide_gpu.dropna()\n", - "\n", - "plt.plot(itk_cpu.index, itk_cpu, label='ITK CPU', marker='o', linestyle='solid', markersize=3)\n", - "plt.plot(itk_gpu.index, itk_gpu, label='ITK GPU', marker='o', linestyle='solid', markersize=3)\n", - "plt.plot(hal_cpu.index, hal_cpu, label='Halide CPU', marker='o', linestyle='solid', markersize=3)\n", - "plt.plot(hal_gpu.index, hal_gpu, label='Halide GPU', marker='o', linestyle='solid', markersize=3)\n", - "\n", - "plt.axvline(12, lw=1, c='k', ls='dotted', label='Default Max. Kernel Size')\n", - "plt.axvline(18, lw=1, c='k', ls='dashed', label='Benchmark max. Kernel Size')\n", - "\n", - "plt.title(\"700x700x700mm Image; 1px/mm\\n(Best of Five)\")\n", - "plt.xlabel('Gaussian Sigma (mm)')\n", - "plt.ylabel('Runtime (ms)')\n", - "plt.ylim(0,500)\n", - "_ = plt.legend()" - ] + "outputs": [], + "source": [] } ], "metadata": { diff --git a/examples/resolution-benchmark.csv b/examples/resolution-benchmark.csv deleted file mode 100644 index c1c8ccc..0000000 --- a/examples/resolution-benchmark.csv +++ /dev/null @@ -1,106 +0,0 @@ -res,itk_cpu,itk_gpu,itk_halide_cpu,itk_halide_gpu -5,2.05878,0.887652,0.518228,0.285408, -5,2.38694,0.740507,0.39476,0.26652, -5,2.08542,0.586593,0.391025,0.231045, -5,2.0028,0.773104,0.399963,0.2733, -5,2.0688,0.673121,0.330807,0.232915, -7,13.9805,1.31175,0.352521,0.561487, -7,13.482,2.02779,0.349928,0.466152, -7,9.87606,1.75787,0.446004,0.508953, -7,7.51551,1.82086,0.492851,0.446006, -7,7.58417,1.83508,0.495194,0.547983, -9,17.7384,4.14811,1.04088,1.08161, -9,17.2354,2.98696,1.01163,0.654189, -9,17.0126,2.80577,0.922786,0.66454, -9,17.3311,2.83363,0.953418,0.656881, -9,16.8549,2.84083,0.907636,0.659016, -11,39.044,5.2201,1.22277,1.20213, -11,36.8549,4.68595,1.22596,1.20238, -11,36.5512,6.75817,1.19895,1.44582, -11,37.4856,4.62723,1.16467,1.16552, -11,39.9891,6.44858,1.19856,1.18194, -13,85.7601,7.17888,1.74557,1.79107, -13,86.2432,7.10563,1.73904,2.39325, -13,83.5867,7.02027,1.84394,1.77373, -13,85.1778,7.15145,1.76039,1.89647, -13,91.308,6.96369,1.76124,1.82143, -15,137.859,10.7025,2.16718,2.60019, -15,141.655,11.0406,2.22802,2.62757, -15,138.194,10.9534,2.29757,3.61299, -15,143.776,10.601,2.17663,2.71728, -15,141.828,10.7921,2.19531,2.65971, -5,2.25242,0.631202,0.263276,0.241124, -5,2.0638,0.57497,0.334889,0.467913, -5,2.01185,0.569282,0.247313,0.221968, -5,2.00497,0.548872,0.269144,0.226878, -5,2.34067,0.556004,0.345638,0.226341, -15,150.738,11.8186,2.14271,3.18739, -15,141.561,11.2242,1.99298,2.48006, -15,141.92,10.7868,1.83168,2.54515, -15,141.099,11.0586,1.89553,3.36662, -15,140.002,11.2266,1.893,2.53118, -25,585.393,48.4495,8.78759,23.3635, -25,556.519,46.9432,8.18714,27.0912, -25,560.909,48.6088,8.24298,24.2776, -25,557.656,46.7446,8.34664,22.7469, -25,557.391,48.9297,8.5405,22.9708, -35,1442.86,130.259,25.6427,63.8841, -35,1422.99,130.682,24.0244,64.423, -35,1456.57,131.28,23.8687,63.1972, -35,1431.14,133.75,24.249,62.7264, -35,1459.73,127.315,24.6223,64.021, -45,nan,251.129,63.5018,137.484, -45,nan,249.165,65.6229,136.813, -45,nan,248.437,64.3235,138.108, -45,nan,252.594,65.1456,145.243, -45,nan,250.731,64.6009,137.569, -10,26.9325,2.43661,0.928763,1.03993, -10,34.0428,2.1062,1.00779,1.57325, -10,34.5295,2.08887,0.815696,1.07241, -10,42.9045,2.57699,0.891692,0.950094, -10,47.1578,2.82721,1.03331,1.08457, -20,355.124,24.4787,6.02498,5.59658, -20,356.199,24.2074,4.80189,7.26126, -20,340.825,24.1843,4.87001,10.1102, -20,353.807,24.3726,4.79925,6.69134, -20,330.413,26.6939,5.07199,5.3883, -30,957.05,79.6032,13.2946,39.8363, -30,948.361,79.4852,13.1585,49.0228, -30,953.237,81.316,13.6795,43.4829, -30,977.047,79.3376,13.6425,40.5899, -30,939.414,85.829,13.061,39.9391, -40,nan,176.56,44.8501,95.4083, -40,nan,174.813,45.3249,117.219, -40,nan,188.098,46.6041,108.477, -40,nan,176.873,45.0066,94.6687, -40,nan,178.147,45.2306,96.0242, -50,nan,342.912,86.2002,194.995, -50,nan,348.178,89.5365,198.199, -50,nan,347.232,84.28,202.776, -50,nan,342.711,86.1753,206.999, -50,nan,343.907,89.1385,190.549, -60,nan,584.524,159.486,331.923, -60,nan,589.73,166.415,337.013, -60,nan,603.143,165.779,332.528, -60,nan,596.381,161.645,335.951, -60,nan,597.222,168.501,339.336, -70,nan,965.67,298.979,542.85, -70,nan,947.954,295.794,543.485, -70,nan,932.236,288.805,530.659, -70,nan,962.128,291.342,538.634, -70,nan,938.943,299.374,544.029, -80,nan,nan,583.475,823.66, -80,nan,nan,573.597,842.13, -80,nan,nan,580.984,819.514, -80,nan,nan,550.121,815.176, -80,nan,nan,543.782,816.104, -90,nan,nan,812.347,1575.52, -90,nan,nan,830.401,1166.16, -90,nan,nan,813.532,1171.96, -90,nan,nan,817.682,1206.87, -90,nan,nan,770.374,1200.28, -100,nan,nan,1152.19,1821.24, -100,nan,nan,1229.11,1656.25, -100,nan,nan,1245.48,1664.93, -100,nan,nan,1325.56,1624.34, -100,nan,nan,1168.09,1626.45, diff --git a/examples/sigma-benchmark.csv b/examples/sigma-benchmark.csv deleted file mode 100644 index be50135..0000000 --- a/examples/sigma-benchmark.csv +++ /dev/null @@ -1,71 +0,0 @@ -sigma,itk_cpu,itk_gpu,itk_halide_cpu,itk_halide_gpu -1,112.527,78.8448,8.5955,37.52, -1,112.492,78.2011,8.30351,36.9045, -1,116.844,77.8111,8.72604,37.2833, -1,110.406,75.2388,8.37585,37.4166, -1,97.1576,78.633,8.71351,38.6973, -2,120.081,77.8378,9.36,38.6488, -2,137.837,77.0513,9.76392,37.5751, -2,123.557,75.3988,9.66694,37.6668, -2,128.349,75.8621,9.65187,37.4581, -2,125.417,75.4397,9.58733,38.1459, -3,185.604,77.2748,11.5034,38.7714, -3,179.276,76.3694,11.2283,39.0541, -3,194.077,75.4534,11.375,38.5823, -3,180.448,78.1322,10.7234,39.2908, -3,189.303,77.9107,11.2767,38.9094, -4,227.439,77.1625,13.013,39.5885, -4,228.578,76.2382,13.1728,39.6108, -4,231.318,81.0918,13.5171,40.4151, -4,232.99,79.14,13.0985,39.4873, -4,226.689,77.1381,13.0623,39.9495, -5,319.622,79.6265,18.4351,42.1398, -5,308.565,77.6357,20.5289,42.0417, -5,302.695,77.3424,18.6834,41.3108, -5,316.471,77.9321,18.8815,41.2403, -5,314.946,77.3027,19.0715,41.7235, -6,nan,78.3674,25.6933,42.8421, -6,nan,77.3937,25.2158,42.7656, -6,nan,77.3049,25.6263,42.8043, -6,nan,77.1831,24.9644,42.2115, -6,nan,77.0227,24.6203,42.5207, -7,nan,78.487,29.5391,43.5035, -7,nan,77.977,28.8704,43.409, -7,nan,77.0052,29.4693,43.5935, -7,nan,87.8683,30.202,45.6302, -7,nan,77.6885,29.5761,43.1435, -8,nan,77.7388,36.5867,51.3883, -8,nan,88.0576,36.7428,45.8924, -8,nan,78.3717,36.6349,44.8019, -8,nan,77.646,36.7422,44.8663, -8,nan,95.1619,35.5042,44.5258, -10,nan,77.9461,53.8817,47.3978, -10,nan,78.5518,53.3747,47.4785, -10,nan,79.5998,53.6889,47.1637, -10,nan,78.5553,56.5442,47.3494, -10,nan,78.6736,53.9924,46.8937, -13,nan,79.8866,88.3101,52.5377, -13,nan,79.4971,87.6406,52.6608, -13,nan,78.897,86.0982,52.9379, -13,nan,79.9935,88.7018,52.6611, -13,nan,79.525,86.7808,52.8141, -16,nan,84.5967,163.021,61.6195, -16,nan,82.3198,159.52,62.772, -16,nan,81.188,161.512,58.8759, -16,nan,80.8233,160.553,60.8885, -16,nan,81.0683,163.313,58.9144, -19,nan,81.1176,nan,61.845, -19,nan,82.1505,nan,61.7105, -19,nan,91.4573,nan,59.6131, -19,nan,81.3196,nan,61.9193, -19,nan,92.9749,nan,59.6477, -22,nan,81.9858,nan,59.9207, -22,nan,80.9173,nan,59.7793, -22,nan,88.2811,nan,60.0283, -22,nan,80.8454,nan,60.0724, -22,nan,83.1576,nan,59.7505, -25,nan,81.6919,nan,61.3668, -25,nan,82.5604,nan,60.0607, -25,nan,82.0541,nan,59.967, -25,nan,89.84,nan,60.7056, -25,nan,81.1479,nan,59.6905,