diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..4cba627 --- /dev/null +++ b/.clang-format @@ -0,0 +1,23 @@ +BasedOnStyle: LLVM +Language: Cpp + +IndentWidth: 2 +ContinuationIndentWidth: 2 +TabWidth: 2 +UseTab: Never + +ColumnLimit: 80 +IndentPPDirectives: None +AlignEscapedNewlines: Left +AlignConsecutiveMacros: None + +BinPackArguments: false +BinPackParameters: false +AllowShortFunctionsOnASingleLine: Empty +AllowShortIfStatementsOnASingleLine: Never +AllowShortLoopsOnASingleLine: false + +BreakBeforeBraces: Attach +PointerAlignment: Right +SortIncludes: Never +ReflowComments: false diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..a321ee9 --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +/.cache +/build +/benchmarks/processed_outputs +/benchmarks/pipeline_outputs \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..b970b1f --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,160 @@ +cmake_minimum_required(VERSION 3.20) + +project(ImageConversation LANGUAGES C) + +set(CMAKE_C_STANDARD 17) +set(CMAKE_C_STANDARD_REQUIRED ON) +set(CMAKE_C_EXTENSIONS OFF) +set(CMAKE_EXPORT_COMPILE_COMMANDS ON) + +include(CTest) +include(FetchContent) +find_package(Threads REQUIRED) +find_package(OpenMP REQUIRED) + +option(IMAGE_CONVERSATION_ENABLE_OPENCV + "Fetch the legacy OpenCV C API target" + OFF) + +file(GLOB_RECURSE FILTER_SOURCES CONFIGURE_DEPENDS + "${CMAKE_CURRENT_SOURCE_DIR}/src/filters/*.c" +) + +file(GLOB_RECURSE CONVOLUTION_RUNTIME_SOURCES CONFIGURE_DEPENDS + "${CMAKE_CURRENT_SOURCE_DIR}/src/convolution/*.c" + "${CMAKE_CURRENT_SOURCE_DIR}/src/gpu_convolution/*.c" + "${CMAKE_CURRENT_SOURCE_DIR}/src/parallel_convolution/*.c" + "${CMAKE_CURRENT_SOURCE_DIR}/src/pipeline/*.c" + "${CMAKE_CURRENT_SOURCE_DIR}/src/sequentially_convolution/*.c" + "${CMAKE_CURRENT_SOURCE_DIR}/src/runtime/*.c" + "${CMAKE_CURRENT_SOURCE_DIR}/src/image_helpers/*.c" +) + +set(BUILD_TESTS OFF CACHE BOOL "") +set(BUILD_PERF_TESTS OFF CACHE BOOL "") +set(BUILD_EXAMPLES OFF CACHE BOOL "") +set(BUILD_DOCS OFF CACHE BOOL "") +set(BUILD_opencv_apps OFF CACHE BOOL "") + +set(BUILD_opencv_core ON CACHE BOOL "") +set(BUILD_opencv_imgproc ON CACHE BOOL "") +set(BUILD_opencv_highgui ON CACHE BOOL "") + +set(BUILD_opencv_ts OFF CACHE BOOL "") +set(BUILD_opencv_calib3d OFF CACHE BOOL "") +set(BUILD_opencv_contrib OFF CACHE BOOL "") +set(BUILD_opencv_features2d OFF CACHE BOOL "") +set(BUILD_opencv_flann OFF CACHE BOOL "") +set(BUILD_opencv_gpu OFF CACHE BOOL "") +set(BUILD_opencv_legacy OFF CACHE BOOL "") +set(BUILD_opencv_ml OFF CACHE BOOL "") +set(BUILD_opencv_nonfree OFF CACHE BOOL "") +set(BUILD_opencv_objdetect OFF CACHE BOOL "") +set(BUILD_opencv_ocl OFF CACHE BOOL "") +set(BUILD_opencv_photo OFF CACHE BOOL "") +set(BUILD_opencv_stitching OFF CACHE BOOL "") +set(BUILD_opencv_superres OFF CACHE BOOL "") +set(BUILD_opencv_video OFF CACHE BOOL "") +set(BUILD_opencv_videostab OFF CACHE BOOL "") +set(BUILD_opencv_world OFF CACHE BOOL "") + +set(WITH_QT OFF CACHE BOOL "") +set(WITH_GTK OFF CACHE BOOL "") +set(WITH_OPENGL OFF CACHE BOOL "") +set(WITH_FFMPEG OFF CACHE BOOL "") +set(WITH_GSTREAMER OFF CACHE BOOL "") +set(WITH_V4L OFF CACHE BOOL "") +set(WITH_1394 OFF CACHE BOOL "") +set(WITH_CUDA OFF CACHE BOOL "") +set(WITH_OPENCL OFF CACHE BOOL "") +set(WITH_TBB OFF CACHE BOOL "") +set(WITH_IPP OFF CACHE BOOL "") +set(WITH_TIFF OFF CACHE BOOL "") +set(WITH_JASPER OFF CACHE BOOL "") +set(WITH_OPENEXR OFF CACHE BOOL "") + +FetchContent_Declare( + opencv + GIT_REPOSITORY https://github.com/opencv/opencv + GIT_TAG 2.4.13.6 + GIT_SHALLOW TRUE +) + +FetchContent_Declare( + opencl_headers + GIT_REPOSITORY https://github.com/KhronosGroup/OpenCL-Headers.git + GIT_TAG v2023.04.17 +) + +FetchContent_Declare( + opencl_icd_loader + GIT_REPOSITORY https://github.com/KhronosGroup/OpenCL-ICD-Loader.git + GIT_TAG v2023.04.17 +) + +FetchContent_MakeAvailable(opencv opencl_headers opencl_icd_loader) + +add_library(opencv_legacy_c_api INTERFACE) +target_include_directories(opencv_legacy_c_api + INTERFACE + ${opencv_SOURCE_DIR}/modules/core/include + ${opencv_SOURCE_DIR}/modules/imgproc/include + ${opencv_SOURCE_DIR}/modules/highgui/include +) +target_link_libraries(opencv_legacy_c_api + INTERFACE + opencv_core + opencv_imgproc + opencv_highgui +) + +add_library(filters_core STATIC + ${FILTER_SOURCES} +) +add_library(filters ALIAS filters_core) + +target_include_directories(filters_core + PUBLIC + ${CMAKE_CURRENT_SOURCE_DIR}/src +) + +add_library(convolution_runtime STATIC + ${CONVOLUTION_RUNTIME_SOURCES} +) +target_include_directories(convolution_runtime + PUBLIC + ${CMAKE_CURRENT_SOURCE_DIR}/src + PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR}/internal + ${opencl_headers_SOURCE_DIR} +) +target_compile_definitions(convolution_runtime + PRIVATE + CL_TARGET_OPENCL_VERSION=300 + GPU_CONVOLUTION_KERNEL_PATH="${CMAKE_CURRENT_SOURCE_DIR}/src/gpu_convolution/gpu_convolution.cl" +) +target_link_libraries(convolution_runtime + PUBLIC + filters_core + opencv_legacy_c_api + OpenCL + Threads::Threads + OpenMP::OpenMP_C +) + +add_executable(app + src/app.c + src/cli_args.c +) +target_link_libraries(app + PRIVATE + convolution_runtime +) + +if(BUILD_TESTING) + find_package(PkgConfig REQUIRED) + pkg_check_modules(CMOCKA REQUIRED IMPORTED_TARGET cmocka) + + add_subdirectory(test/sequential_tests) + add_subdirectory(test/thread_pool_tests) +endif() diff --git a/README.md b/README.md index 587628d..22a2c92 100644 --- a/README.md +++ b/README.md @@ -1,8 +1,429 @@ # Image Conversation -Основная ветка намеренно оставлена минимальной. +Image Conversation — консольное приложение для применения фильтров к одному изображению или к набору изображений. -Реализации задач разнесены по отдельным веткам: +## Запуск программы + +### Сборка + +Для обычного запуска программы достаточно собрать таргет `app` в release-конфигурации: + +```bash +cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DBUILD_TESTING=OFF +cmake --build build --target app -j +``` + +После сборки исполняемый файл находится в `build/bin/app`. + +### Пример для одного изображения + +```bash +./build/bin/app \ + -i input/satoru.jpg -o output/satoru.jpg \ + -f gauss -h 5 -w 5 \ + -f sharpen -h 3 -w 3 \ + -p rows +``` + +### Пример для нескольких изображений + +Для пакетной обработки нужно несколько раз передать пару `-i -o `. Набор фильтров и режим выполнения применяются ко всем изображениям из запуска. + +```bash +./build/bin/app \ + -i input/satoru.jpg -o output/satoru.jpg \ + -i input/sunshine.jpg -o output/sunshine.jpg \ + -f gauss -h 5 -w 5 \ + -f sharpen -h 3 -w 3 \ + -p rows +``` + +### Аргументы запуска + +Поддерживаются один или два фильтра за один запуск. Фильтр задаётся через `-f -h -w `. Для направленных фильтров можно дополнительно указать `-t `. + +Доступные имена фильтров: `blur`, `mean`, `gauss`, `motion`, `edge`, `sharpen`, `emboss`, `median`. + +Последний аргумент выбирает режим выполнения: + +| Режим | Что делает | +|---|---| +| `-s` | последовательная свёртка | +| `-p rows` | параллельная обработка по строкам | +| `-p cols` | параллельная обработка по столбцам | +| `-p pixels` | параллельная обработка по пикселям | +| `-p grid` | параллельная обработка по прямоугольным блокам | + +Справку по формату аргументов можно вывести так: + +```bash +./build/bin/app --help +``` + +## Запуск тестов + +Тесты подключены через CTest. Для их сборки нужна установленная `cmocka`. + +```bash +cmake -S . -B build-tests -DCMAKE_BUILD_TYPE=Debug -DBUILD_TESTING=ON +cmake --build build-tests -j +ctest --test-dir build-tests --output-on-failure +``` + +## Как запустить бенчмарки у себя + +Бенчмарки лучше запускать на release-сборке: debug-сборка исказит сравнение режимов свёртки. + +```bash +cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DBUILD_TESTING=OFF +cmake --build build --target app -j +python3 scripts/benchmark_readme.py +``` + +Скрипт `scripts/benchmark_readme.py` запускает все режимы по 10 раз, сохраняет сырые данные в [`benchmarks/readme_benchmark_results.json`](benchmarks/readme_benchmark_results.json) и обновляет графики в `benchmarks/`. Для запуска нужны Python-пакеты `matplotlib`, `numpy` и `Pillow`. + +Если нужно ограничить число потоков OpenMP, задайте `OMP_NUM_THREADS` перед запуском: + +```bash +OMP_NUM_THREADS=8 python3 scripts/benchmark_readme.py +``` + +## Бенчмарки + +Эта секция содержит уже полученные замеры. Команды для воспроизведения на своём компьютере приведены выше. + +### Что измерялось + +В текущих замерах сравнивается пайплайн из двух фильтров: + +```text +gauss 5x5 -> sharpen 3x3 +``` + +Время указано в миллисекундах. Один замер включает полный проход `image_pipeline_run`: чтение изображения, применение фильтров и запись результата. Каждый режим запускался 10 раз, в таблицах показано среднее время. Подробные значения всех запусков лежат в [`benchmarks/readme_benchmark_results.json`](benchmarks/readme_benchmark_results.json). + +### Окружение + +| Параметр | Значение | +|---|---| +| CPU | Intel(R) Core(TM) Ultra 5 125H | +| Architecture | x86_64 | +| Логических CPU | 18 | +| Список CPU | 0-17 | +| Ядер на сокет | 14 | +| Потоков на ядро | 2 | +| Максимальная частота CPU | 4600 MHz | +| Минимальная частота CPU | 400 MHz | +| L1d cache | 448 KiB | +| L1i cache | 768 KiB | +| L2 cache | 14 MiB | +| L3 cache | 18 MiB | +| RAM | 32260660 kB, примерно 30.8 GiB | +| Потоков OpenMP | 18 | +| Запусков на режим | 10 | + +### Сокращения в таблицах + +| Сокращение | Значение | +|---|---| +| `seq` | последовательная свёртка | +| `rows` | параллельная свёртка по строкам | +| `cols` | параллельная свёртка по столбцам | +| `pixels` | параллельная свёртка по пикселям | +| `grid` | параллельная свёртка по прямоугольным блокам | +| `ms` | миллисекунды | +| `Min` / `Max` | минимальное и максимальное время среди 10 запусков | +| `95% CI` | 95% доверительный интервал среднего значения | +| `CV` | coefficient of variation, относительный разброс `s / mean` | +| `x`, `speedup` | ускорение относительно последовательного режима `seq` | + +### Краткие выводы + +На маленьких изображениях все параллельные режимы близки друг к другу: накладные расходы на запуск потоков и синхронизацию уже заметны, поэтому разница между стратегиями небольшая. + +На крупных изображениях лучше всего показал себя режим `rows`. Для `musashi.jpg` он дал ускорение примерно `6.64x`, а на пайплайне из десяти 4K-изображений — `5.81x`. Режимы `cols`, `pixels` и `grid` тоже дают существенное ускорение, но в этих замерах чаще уступают разбиению по строкам. + +Основная причина преимущества `rows` на больших изображениях — лучшая кэш-локальность. Изображение хранится построчно: соседние пиксели одной строки лежат рядом в памяти, а расстояние между соседними строками равно количеству байт между началами двух этих строк с учетом возможного выравнивания. В режиме `rows` каждый поток получает непрерывный диапазон строк, последовательно читает и пишет большие линейные участки памяти, что обеспечивает лучшую кэш-локальность. В режиме `cols` потоки обрабатывают вертикальные полосы: внутри каждой строки доступ по-прежнему последовательный, но все потоки проходят одни и те же строки разными полосами, чаще пересекаются на границах кэш-линий и создают больше давления на кэш/TLB. В режиме `pixels` единица работы слишком мелкая, а `convolution_apply_pixel` выполняет проверки для каждого пикселя. В режиме `grid` локальность внутри плитки хорошая, но появляется больше мелких прямоугольных областей и накладных расходов на разбиение; на маленьких изображениях это иногда помогает, а на больших чаще проигрывает простому линейному проходу по строкам. + +Если `cols` или `grid` в отдельной строке таблицы оказываются немного быстрее `rows`, это не обязательно ошибка в коде или в замерах. Например, для `stariy_bog.png` средние `cols = 81.0 ms` и `rows = 81.2 ms` отличаются меньше, чем доверительный интервал измерений. Для маленьких изображений накладные расходы потоков, планирование OpenMP, состояние CPU frequency scaling и фоновые процессы могут быть сравнимы с самой полезной работой. Поэтому небольшую разницу внутри погрешности стоит читать как статистически незначимую, а устойчивый вывод лучше делать по крупным изображениям и пакетному сценарию. + +### Одно изображение + +В этом сценарии один запуск программы обрабатывает одно изображение из `input/`. + +#### Сводная таблица + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ИзображениеРазмерСреднее время, msЛучший параллельный режим
seqrowscolspixelsgrid
satoru.jpg225x22553.113.714.514.913.3grid, 3.99x
sunshine.jpg300x16853.912.712.912.813.2rows, 4.24x
stariy_bog.png914x480424.981.281.081.982.8cols, 5.25x
musashi.jpg2560x14403518.7530.3540.0556.0536.6rows, 6.64x
sea.png3840x21607929.21585.41860.41830.51814.1rows, 5.00x
+ +#### Оценка погрешности + +Погрешность ниже посчитана как 95% доверительный интервал среднего по 10 запускам: `mean ± 2.262 * s / sqrt(10)`, где `s` — выборочное стандартное отклонение. В скобках указан `CV = s / mean`, то есть относительный разброс. + +| Изображение | `seq`, ms | `rows`, ms | `cols`, ms | `pixels`, ms | `grid`, ms | +|---|---:|---:|---:|---:|---:| +| `input/satoru.jpg` | 53.1 ± 2.3 (6.0%) | 13.7 ± 0.9 (9.0%) | 14.5 ± 2.1 (20.1%) | 14.9 ± 1.3 (12.3%) | 13.3 ± 0.9 (9.1%) | +| `input/sunshine.jpg` | 53.9 ± 1.9 (5.0%) | 12.7 ± 1.1 (12.5%) | 12.9 ± 1.1 (11.5%) | 12.8 ± 1.3 (13.8%) | 13.2 ± 0.7 (7.0%) | +| `input/stariy_bog.png` | 424.9 ± 2.8 (0.9%) | 81.2 ± 4.9 (8.4%) | 81.0 ± 3.0 (5.1%) | 81.9 ± 1.9 (3.2%) | 82.8 ± 3.1 (5.3%) | +| `input/musashi.jpg` | 3518.7 ± 58.6 (2.3%) | 530.3 ± 5.3 (1.4%) | 540.0 ± 8.9 (2.3%) | 556.0 ± 21.2 (5.3%) | 536.6 ± 18.3 (4.8%) | +| `input/sea.png` | 7929.2 ± 41.1 (0.7%) | 1585.4 ± 213.9 (18.9%) | 1860.4 ± 47.3 (3.6%) | 1830.5 ± 25.8 (2.0%) | 1814.1 ± 33.6 (2.6%) | + +#### Подробно по каждому изображению + +##### `satoru.jpg`, 225x225 + + + + + + + + + + + + + + + + + + + + + +
РежимВремя, msУскорение относительно seq
СреднееMinMax
seq53.149.059.01.00x
rows13.711.715.73.88x
cols14.511.621.33.66x
pixels14.913.018.83.56x
grid13.311.815.33.99x
+ +![Benchmark for satoru.jpg](benchmarks/readme_single_satoru_gauss_5x5_then_sharpen_3x3_benchmark.png) + +##### `sunshine.jpg`, 300x168 + + + + + + + + + + + + + + + + + + + + + +
РежимВремя, msУскорение относительно seq
СреднееMinMax
seq53.951.159.31.00x
rows12.79.215.04.24x
cols12.911.115.74.16x
pixels12.810.316.44.21x
grid13.212.115.34.09x
+ +![Benchmark for sunshine.jpg](benchmarks/readme_single_sunshine_gauss_5x5_then_sharpen_3x3_benchmark.png) + +##### `stariy_bog.png`, 914x480 + + + + + + + + + + + + + + + + + + + + + +
РежимВремя, msУскорение относительно seq
СреднееMinMax
seq424.9415.5429.51.00x
rows81.270.190.75.23x
cols81.074.988.35.25x
pixels81.978.886.45.19x
grid82.877.491.45.13x
+ +![Benchmark for stariy_bog.png](benchmarks/readme_single_stariy_bog_gauss_5x5_then_sharpen_3x3_benchmark.png) + +##### `musashi.jpg`, 2560x1440 + + + + + + + + + + + + + + + + + + + + + +
РежимВремя, msУскорение относительно seq
СреднееMinMax
seq3518.73457.53730.41.00x
rows530.3519.6542.96.64x
cols540.0522.7567.36.52x
pixels556.0521.0619.96.33x
grid536.6517.9603.16.56x
+ +![Benchmark for musashi.jpg](benchmarks/readme_single_musashi_gauss_5x5_then_sharpen_3x3_benchmark.png) + +##### `sea.png`, 3840x2160 + + + + + + + + + + + + + + + + + + + + + +
РежимВремя, msУскорение относительно seq
СреднееMinMax
seq7929.27856.48061.11.00x
rows1585.41237.31871.25.00x
cols1860.41761.91990.64.26x
pixels1830.51799.21916.14.33x
grid1814.11730.61890.54.37x
+ +![Benchmark for sea.png](benchmarks/readme_single_sea_gauss_5x5_then_sharpen_3x3_benchmark.png) + +### Пайплайн из 10 4K-изображений + +В этом сценарии один запуск программы получает сразу 10 изображений размером 3840x2160. Это ближе к пакетной обработке: накладные расходы распределяются на больший объём работы, а разница между стратегиями распараллеливания становится заметнее. + + + + + + + + + + + + + + + + + + + + + +
РежимВремя, msУскорение относительно seq
СреднееMinMax
seq76841.276084.977188.11.00x
rows13222.710178.515360.25.81x
cols14879.314739.115006.55.16x
pixels15510.814846.216740.94.95x
grid15559.014962.516204.34.94x
+ +Оценка погрешности для пакетного сценария: + +| Режим | Среднее ± 95% CI, ms | Станд. отклонение, ms | CV | +|---|---:|---:|---:| +| `seq` | 76841.2 ± 225.5 | 315.2 | 0.4% | +| `rows` | 13222.7 ± 1615.3 | 2258.0 | 17.1% | +| `cols` | 14879.3 ± 64.9 | 90.8 | 0.6% | +| `pixels` | 15510.8 ± 511.8 | 715.5 | 4.6% | +| `grid` | 15559.0 ± 328.1 | 458.6 | 2.9% | + +У `rows` в пакетном сценарии разброс заметно выше: первые четыре запуска были около 10.2-11.1 с, следующие — около 14.8-15.4 с. Поэтому среднее `rows` быстрее остальных режимов, но именно этот результат имеет самую широкую погрешность и требует аккуратной интерпретации. + +![Benchmark for 10-image pipeline](benchmarks/readme_pipeline_gauss_5x5_then_sharpen_3x3_benchmark.png) + +
+Список изображений из пакетного сценария + +| # | Файл | Размер | +|---:|---|---:| +| 1 | `171406-odin_udar_chelovek_dvojnoe_proniknovenie-prefektura_sajtama-odin_udar_chelovek-anime-rukav-3840x2160.jpg` | 3840x2160 | +| 2 | `172836-ikona-asfalt-dorozhnoe_pokrytie-most-zdanie-3840x2160.png` | 3840x2160 | +| 3 | `173960-galaktika_andromedy-galaktika-mlechnyj_put-zemlya-zvezda-3840x2160.jpg` | 3840x2160 | +| 4 | `175978-yastreb-hishhnaya_ptica-sokol-nauka-biologiya-3840x2160.jpg` | 3840x2160 | +| 5 | `176372-oblako-gora-voda-rastenie-prirodnyj_landshaft-3840x2160.jpg` | 3840x2160 | +| 6 | `176515-samolet-samolety-polet-reaktivnyj_samolet-aviaciya-3840x2160.jpg` | 3840x2160 | +| 7 | `176585-albert_ejnshtejn_iskusstvo-art-poster-dizajn-nauka-3840x2160.jpg` | 3840x2160 | +| 8 | `179158-kon-belye-pechen-nazemnye_zhivotnye-prirodnyj_landshaft-3840x2160.jpg` | 3840x2160 | +| 9 | `181366-nytol_herbal_30_tabletok-nosok-bunionektomiya-dostupnyj-prigonka-3840x2160.jpg` | 3840x2160 | +| 10 | `img3.akspic.ru-nebo-kosmicheskoe_prostranstvo-film-gorizont-atmosfera-3840x2160.jpg` | 3840x2160 | + +
- `feat/sequential_convolution` — последовательная свёртка. - `feat/parallel_convolution` — параллельная свёртка поверх последовательной реализации. diff --git a/docs/task3/README.md b/docs/task3/README.md new file mode 100644 index 0000000..b96b6d5 --- /dev/null +++ b/docs/task3/README.md @@ -0,0 +1,39 @@ +# Бенчмарк размера очередей пайплайна обработки изображений + +![График зависимости времени от размера computer очереди](./pipeline_queue_benchmark.png) + +Измерялась зависимость полного времени обработки пайплайна от размера очереди `computer`. Всего в пайплайне три очереди: `reader → computer → writer`. + +## Параметры эксперимента + +| Параметр | Значение | +|---|---:| +| Изображений | `10` (`3840x2160`) | +| Всего потоков | `18` | +| Reader threads | `2` | +| Writer threads | `2` | +| Computer budget | `14` | +| Размер reader queue | `4` | +| Размер writer queue | `4` | +| Размеры computer queue | `2, 3, 4, 5` | +| Запусков на кейс | `10` | +| Фильтры | `motion_blur 9x9 + gauss 5x5` | + +## Режимы + +Все 4 режима — параллельные (`cols`, `raw`, `pixel`, `grid`). +Каждый запускает 2 computer workers, каждый с `omp_set_num_threads(7)`. +Reader и writer — по 2 pthread-потока. + +## Таблица результатов + +| Computer queue | cols, мс | raw, мс | pixel, мс | grid, мс | +|---:|---:|---:|---:|---:| +| 1 | `7421.71 +- 1282.75` | `8612.90 +- 743.29` | `8346.87 +- 276.93` | `8299.32 +- 341.48` | +| 2 | `8313.90 +- 388.42` | `8586.23 +- 658.12` | `8269.55 +- 782.90` | `8271.16 +- 501.81` | +| 3 | `8054.89 +- 54.17` | `8056.21 +- 131.04` | `8123.54 +- 145.74` | `8312.45 +- 650.10` | +| 4 | `8683.15 +- 337.37` | `8507.49 +- 1295.75` | `8126.86 +- 223.49` | `8081.86 +- 162.74` | + +## Лучшие конфигурации + +- **cols**: минимум 7421.7 мс при computer_queue=1- **raw**: минимум 8056.2 мс при computer_queue=3- **pixel**: минимум 8123.5 мс при computer_queue=3- **grid**: минимум 8081.9 мс при computer_queue=4 diff --git a/docs/task3/pipeline_queue_benchmark.png b/docs/task3/pipeline_queue_benchmark.png new file mode 100644 index 0000000..e19f388 Binary files /dev/null and b/docs/task3/pipeline_queue_benchmark.png differ diff --git a/docs/task4/README.md b/docs/task4/README.md new file mode 100644 index 0000000..f786304 --- /dev/null +++ b/docs/task4/README.md @@ -0,0 +1,16 @@ +# Задача 4: Свёртка на GPU + +В данной задаче реализовано ускорение свёртки изображений с использованием **OpenCL**. + +## Результаты бенчмарков + +Замер проводился в режиме пайплайна для **10 изображений в разрешении 4K** (3840x2160). +Цепочка фильтров: `gauss 5x5 -> sharpen 3x3`. + +| Режим | Тип | Среднее время (мс) | Ускорение (vs seq) | +| :--- | :--- | :--- | :--- | +| **Sequential** | CPU (1 поток) | ~75 000 | 1.00x | +| **Parallel Rows** | CPU (Multi-thread) | ~13 000 | ~5.8x | +| **GPU (OpenCL)** | GPU | **~1 600** | **~45.0x** | +| **Hybrid** | CPU + GPU | ~7 000 | ~10.5x | + diff --git a/docs/task4/pipeline_benchmark.png b/docs/task4/pipeline_benchmark.png new file mode 100644 index 0000000..e95541d Binary files /dev/null and b/docs/task4/pipeline_benchmark.png differ diff --git a/input/171406-odin_udar_chelovek_dvojnoe_proniknovenie-prefektura_sajtama-odin_udar_chelovek-anime-rukav-3840x2160.jpg b/input/171406-odin_udar_chelovek_dvojnoe_proniknovenie-prefektura_sajtama-odin_udar_chelovek-anime-rukav-3840x2160.jpg new file mode 100644 index 0000000..9c2ce56 Binary files /dev/null and b/input/171406-odin_udar_chelovek_dvojnoe_proniknovenie-prefektura_sajtama-odin_udar_chelovek-anime-rukav-3840x2160.jpg differ diff --git a/input/172836-ikona-asfalt-dorozhnoe_pokrytie-most-zdanie-3840x2160.png b/input/172836-ikona-asfalt-dorozhnoe_pokrytie-most-zdanie-3840x2160.png new file mode 100644 index 0000000..538e2a1 Binary files /dev/null and b/input/172836-ikona-asfalt-dorozhnoe_pokrytie-most-zdanie-3840x2160.png differ diff --git a/input/173960-galaktika_andromedy-galaktika-mlechnyj_put-zemlya-zvezda-3840x2160.jpg b/input/173960-galaktika_andromedy-galaktika-mlechnyj_put-zemlya-zvezda-3840x2160.jpg new file mode 100644 index 0000000..d7976ee Binary files /dev/null and b/input/173960-galaktika_andromedy-galaktika-mlechnyj_put-zemlya-zvezda-3840x2160.jpg differ diff --git a/input/175978-yastreb-hishhnaya_ptica-sokol-nauka-biologiya-3840x2160.jpg b/input/175978-yastreb-hishhnaya_ptica-sokol-nauka-biologiya-3840x2160.jpg new file mode 100644 index 0000000..4a37dfe Binary files /dev/null and b/input/175978-yastreb-hishhnaya_ptica-sokol-nauka-biologiya-3840x2160.jpg differ diff --git a/input/176372-oblako-gora-voda-rastenie-prirodnyj_landshaft-3840x2160.jpg b/input/176372-oblako-gora-voda-rastenie-prirodnyj_landshaft-3840x2160.jpg new file mode 100644 index 0000000..99b9f81 Binary files /dev/null and b/input/176372-oblako-gora-voda-rastenie-prirodnyj_landshaft-3840x2160.jpg differ diff --git a/input/176515-samolet-samolety-polet-reaktivnyj_samolet-aviaciya-3840x2160.jpg b/input/176515-samolet-samolety-polet-reaktivnyj_samolet-aviaciya-3840x2160.jpg new file mode 100644 index 0000000..5c8e462 Binary files /dev/null and b/input/176515-samolet-samolety-polet-reaktivnyj_samolet-aviaciya-3840x2160.jpg differ diff --git a/input/176585-albert_ejnshtejn_iskusstvo-art-poster-dizajn-nauka-3840x2160.jpg b/input/176585-albert_ejnshtejn_iskusstvo-art-poster-dizajn-nauka-3840x2160.jpg new file mode 100644 index 0000000..9217e87 Binary files /dev/null and b/input/176585-albert_ejnshtejn_iskusstvo-art-poster-dizajn-nauka-3840x2160.jpg differ diff --git a/input/179158-kon-belye-pechen-nazemnye_zhivotnye-prirodnyj_landshaft-3840x2160.jpg b/input/179158-kon-belye-pechen-nazemnye_zhivotnye-prirodnyj_landshaft-3840x2160.jpg new file mode 100644 index 0000000..a1dc170 Binary files /dev/null and b/input/179158-kon-belye-pechen-nazemnye_zhivotnye-prirodnyj_landshaft-3840x2160.jpg differ diff --git a/input/181366-nytol_herbal_30_tabletok-nosok-bunionektomiya-dostupnyj-prigonka-3840x2160.jpg b/input/181366-nytol_herbal_30_tabletok-nosok-bunionektomiya-dostupnyj-prigonka-3840x2160.jpg new file mode 100644 index 0000000..d30a817 Binary files /dev/null and b/input/181366-nytol_herbal_30_tabletok-nosok-bunionektomiya-dostupnyj-prigonka-3840x2160.jpg differ diff --git a/input/img3.akspic.ru-nebo-kosmicheskoe_prostranstvo-film-gorizont-atmosfera-3840x2160.jpg b/input/img3.akspic.ru-nebo-kosmicheskoe_prostranstvo-film-gorizont-atmosfera-3840x2160.jpg new file mode 100644 index 0000000..45e05a2 Binary files /dev/null and b/input/img3.akspic.ru-nebo-kosmicheskoe_prostranstvo-film-gorizont-atmosfera-3840x2160.jpg differ diff --git a/input/musashi.jpg b/input/musashi.jpg new file mode 100644 index 0000000..5f2320c Binary files /dev/null and b/input/musashi.jpg differ diff --git a/input/satoru.jpg b/input/satoru.jpg new file mode 100644 index 0000000..20c56ff Binary files /dev/null and b/input/satoru.jpg differ diff --git a/input/sea.png b/input/sea.png new file mode 100644 index 0000000..50ddda1 Binary files /dev/null and b/input/sea.png differ diff --git a/input/stariy_bog.png b/input/stariy_bog.png new file mode 100644 index 0000000..a8df030 Binary files /dev/null and b/input/stariy_bog.png differ diff --git a/input/sunshine.jpg b/input/sunshine.jpg new file mode 100644 index 0000000..7fc4963 Binary files /dev/null and b/input/sunshine.jpg differ diff --git a/internal/sequentially_convolution/helper_functions.h b/internal/sequentially_convolution/helper_functions.h new file mode 100644 index 0000000..6c9a653 --- /dev/null +++ b/internal/sequentially_convolution/helper_functions.h @@ -0,0 +1,64 @@ +#pragma once + +#include + +#include + +static inline unsigned char clamp_to_u8(double value) { + if (value < 0.0) { + return 0U; + } + if (value > 255.0) { + return 255U; + } + return (unsigned char)(value + 0.5); +} + +static inline size_t wrap_index(long value, size_t limit) { + long wrapped = value % (long)limit; + if (wrapped < 0) { + wrapped += (long)limit; + } + return (size_t)wrapped; +} + +static inline size_t clamp_index(long value, size_t limit) { + if (value < 0) { + return 0U; + } + if ((size_t)value >= limit) { + return limit - 1U; + } + return (size_t)value; +} + +static inline size_t reflect_index(long value, size_t limit) { + if (limit <= 1U) { + return 0U; + } + + const long period = 2L * ((long)limit - 1L); + long reflected = value % period; + + if (reflected < 0) { + reflected += period; + } + if (reflected >= (long)limit) { + reflected = period - reflected; + } + + return (size_t)reflected; +} + +static inline size_t +resolve_index(long value, size_t limit, filter_border_mode_t border_mode) { + switch (border_mode) { + case FILTER_BORDER_CLAMP: + return clamp_index(value, limit); + case FILTER_BORDER_REFLECT: + return reflect_index(value, limit); + case FILTER_BORDER_WRAP: + default: + return wrap_index(value, limit); + } +} diff --git a/output/.gitkeep b/output/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/scripts/benchmark_images.py b/scripts/benchmark_images.py new file mode 100644 index 0000000..1c37d98 --- /dev/null +++ b/scripts/benchmark_images.py @@ -0,0 +1,213 @@ +#!/usr/bin/env python3 + +import re +import statistics +import subprocess +from pathlib import Path + +import matplotlib + +matplotlib.use("Agg") + +import matplotlib.pyplot as plt +import numpy as np +from PIL import Image + + +ROOT = Path(__file__).resolve().parent.parent +INPUT_DIR = ROOT / "input" +BENCHMARK_DIR = ROOT / "benchmarks" +PROCESSED_DIR = BENCHMARK_DIR / "processed_outputs" +APP = ROOT / "build" / "bin" / "app" + +RUNS = 10 +MODES = ["seq", "rows", "cols", "pixels", "grid"] + +TIME_PATTERN = re.compile(r"processing time:\s*([0-9]+(?:\.[0-9]+)?)\s*ms") + +CASES = [ + ("gauss_5x5", "gauss 5x5", [("gauss", 5, 5, None)]), + ("mean_5x5", "mean 5x5", [("mean", 5, 5, None)]), + ("motion_9x9", "motion 9x9", [("motion", 9, 9, None)]), + ("sharpen_5x5", "sharpen 5x5", [("sharpen", 5, 5, None)]), + ("edge_diagonal_5x5", "edge diagonal 5x5", [("edge", 5, 5, "diagonal")]), + ( + "gauss_5x5_then_sharpen_3x3", + "gauss 5x5 -> sharpen 3x3", + [("gauss", 5, 5, None), ("sharpen", 3, 3, None)], + ), + ( + "motion_9x9_then_edge_omni_3x3", + "motion 9x9 -> edge omni 3x3", + [("motion", 9, 9, None), ("edge", 3, 3, "omni")], + ), +] + +MODE_NAMES = { + "seq": "Sequential", + "rows": "Parallel rows", + "cols": "Parallel cols", + "pixels": "Parallel pixels", + "grid": "Parallel grid", +} + +MODE_COLORS = { + "seq": "#BC3C28", + "rows": "#0072B5", + "cols": "#2E8B57", + "pixels": "#8A52A1", + "grid": "#C58B00", +} + + +def get_images(): + images = [] + + for path in sorted(INPUT_DIR.iterdir()): + if path.suffix.lower() not in {".jpg", ".jpeg", ".png"}: + continue + + with Image.open(path) as image: + width, height = image.size + + images.append( + { + "path": path, + "name": path.name, + "stem": path.stem, + "width": width, + "height": height, + "megapixels": width * height / 1_000_000, + } + ) + + return images + + +def build_command(image, filters, mode, output_path): + command = [str(APP), "-i", str(image["path"]), "-o", str(output_path)] + + for name, height, width, filter_type in filters: + command += ["-f", name, "-h", str(height), "-w", str(width)] + if filter_type: + command += ["-t", filter_type] + + if mode == "seq": + command += ["-s"] + else: + command += ["-p", mode] + + return command + + +def run_program(command): + result = subprocess.run(command, check=True, capture_output=True, text=True) + return float(TIME_PATTERN.search(result.stdout).group(1)) + + +def run_benchmark(image, case_name, filters): + results = {} + + for mode in MODES: + values = [] + + for run_number in range(1, RUNS + 1): + output_path = PROCESSED_DIR / f"{image['stem']}_{case_name}_{mode}_{run_number}.png" + values.append(run_program(build_command(image, filters, mode, output_path))) + + results[mode] = { + "values": values, + "mean": statistics.fmean(values), + "min": min(values), + "max": max(values), + } + + seq_mean = results["seq"]["mean"] + for mode in MODES: + results[mode]["speedup"] = seq_mean / results[mode]["mean"] + + return results + + +def draw_plot(image, case_name, case_title, results): + fig, ax = plt.subplots(figsize=(16, 10), dpi=180) + fig.patch.set_facecolor("#f6f3ee") + ax.set_facecolor("#fffdfa") + + all_values = [value for mode in MODES for value in results[mode]["values"]] + min_time = min(all_values) + max_time = max(all_values) + padding = max(max_time - min_time, max_time * 0.15, 5.0) + ax.set_ylim(max(0, min_time - padding * 0.18), max_time + padding * 0.42) + + for x, mode in enumerate(MODES): + values = results[mode]["values"] + mean = results[mode]["mean"] + color = MODE_COLORS[mode] + jitter = np.linspace(-0.18, 0.18, len(values)) + + ax.scatter( + x + jitter, + values, + s=95, + color=color, + alpha=0.78, + edgecolors="white", + linewidths=1.2, + zorder=3, + ) + ax.vlines(x, results[mode]["min"], results[mode]["max"], color=color, alpha=0.35, linewidth=3) + ax.scatter([x], [mean], marker="D", s=185, color="#111111", edgecolors="white", linewidths=1.6) + ax.hlines(mean, x - 0.22, x + 0.22, color="#111111", linewidth=2.6) + + ax.text( + x, + results[mode]["max"] + padding * 0.06, + f"mean {mean:.1f} ms\n{results[mode]['speedup']:.2f}x vs seq", + ha="center", + va="bottom", + fontsize=13, + fontweight="bold", + ) + + ax.grid(axis="y", color="#d9d2c7", linewidth=1.0, alpha=0.85) + ax.set_axisbelow(True) + ax.set_xticks(range(len(MODES))) + ax.set_xticklabels([MODE_NAMES[mode] for mode in MODES], fontsize=14, fontweight="bold") + ax.set_ylabel("Processing time, ms", fontsize=16, fontweight="bold") + ax.set_xlabel("Execution mode", fontsize=16, fontweight="bold") + ax.tick_params(axis="y", labelsize=13) + + ax.spines["top"].set_visible(False) + ax.spines["right"].set_visible(False) + ax.spines["left"].set_color("#7a746b") + ax.spines["bottom"].set_color("#7a746b") + ax.axhline(results["seq"]["mean"], color=MODE_COLORS["seq"], linestyle="--", linewidth=1.8, alpha=0.55) + + fig.suptitle( + f"{image['name']} | {case_name}\n" + f"{image['width']}x{image['height']} px | {image['megapixels']:.2f} MP | {case_title}", + fontsize=20, + fontweight="bold", + y=0.97, + ) + ax.set_title("10 launch points per mode", fontsize=14, pad=18) + + fig.tight_layout(rect=(0, 0, 1, 0.93)) + fig.savefig(BENCHMARK_DIR / f"{image['stem']}_{case_name}_benchmark.png", bbox_inches="tight") + plt.close(fig) + + +def main(): + BENCHMARK_DIR.mkdir(exist_ok=True) + PROCESSED_DIR.mkdir(exist_ok=True) + + for image in get_images(): + for case_name, case_title, filters in CASES: + print(f"{image['name']} | {case_name}") + results = run_benchmark(image, case_name, filters) + draw_plot(image, case_name, case_title, results) + + +if __name__ == "__main__": + main() diff --git a/scripts/benchmark_pipeline.py b/scripts/benchmark_pipeline.py new file mode 100644 index 0000000..3140d46 --- /dev/null +++ b/scripts/benchmark_pipeline.py @@ -0,0 +1,239 @@ +#!/usr/bin/env python3 + +import re +import statistics +import subprocess +from pathlib import Path + +import matplotlib + +matplotlib.use("Agg") + +import matplotlib.pyplot as plt +import numpy as np + + +ROOT = Path(__file__).resolve().parent.parent +INPUT_DIR = ROOT / "input" +BENCHMARK_DIR = ROOT / "benchmarks" +PROCESSED_DIR = BENCHMARK_DIR / "pipeline_outputs" +APP = ROOT / "build" / "bin" / "app" + +RUNS = 10 +MODES = ["seq", "rows", "cols", "pixels", "grid"] +IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png"} +TIME_PATTERN = re.compile(r"processing time:\s*([0-9]+(?:\.[0-9]+)?)\s*ms") +MIN_4K_WIDTH = 3840 +MIN_4K_HEIGHT = 2160 + +CASE_NAME = "gauss_5x5_then_sharpen_3x3" +CASE_TITLE = "gauss 5x5 -> sharpen 3x3" +FILTERS = [ + ("gauss", 5, 5, None), + ("sharpen", 3, 3, None), +] + +MODE_NAMES = { + "seq": "Sequential", + "rows": "Parallel rows", + "cols": "Parallel cols", + "pixels": "Parallel pixels", + "grid": "Parallel grid", +} + +MODE_COLORS = { + "seq": "#BC3C28", + "rows": "#0072B5", + "cols": "#2E8B57", + "pixels": "#8A52A1", + "grid": "#C58B00", +} + + +def get_input_images(): + images = [] + + for path in sorted(INPUT_DIR.iterdir()): + if path.suffix.lower() not in IMAGE_EXTENSIONS: + continue + if "3840x2160" not in path.name: + continue + + from PIL import Image + + with Image.open(path) as image: + width, height = image.size + + if width >= MIN_4K_WIDTH and height >= MIN_4K_HEIGHT: + images.append(path) + + return images[:10] + + +def build_command(images, mode, run_number): + command = [str(APP)] + + for image_index, image_path in enumerate(images, start=1): + output_name = f"image_{image_index:02d}_{CASE_NAME}_pipeline_{mode}.png" + command += ["-i", str(image_path), "-o", str(PROCESSED_DIR / output_name)] + + for filter_name, height, width, filter_type in FILTERS: + command += ["-f", filter_name, "-h", str(height), "-w", str(width)] + if filter_type is not None: + command += ["-t", filter_type] + + if mode == "seq": + command += ["-s"] + else: + command += ["-p", mode] + + return command + + +def run_program(command): + completed = subprocess.run(command, check=True, capture_output=True, text=True) + match = TIME_PATTERN.search(completed.stdout) + if match is None: + raise RuntimeError("application output does not contain processing time") + + return float(match.group(1)) + + +def run_benchmark(images): + results = {} + + for mode in MODES: + values = [] + for run_number in range(1, RUNS + 1): + command = build_command(images, mode, run_number) + values.append(run_program(command)) + + results[mode] = { + "values": values, + "mean": statistics.fmean(values), + "min": min(values), + "max": max(values), + } + + seq_mean = results["seq"]["mean"] + for mode in MODES: + results[mode]["speedup"] = seq_mean / results[mode]["mean"] + + return results + + +def draw_plot(results, image_count): + fig, ax = plt.subplots(figsize=(16, 10), dpi=180) + fig.patch.set_facecolor("#f6f3ee") + ax.set_facecolor("#fffdfa") + + all_values = [value for mode in MODES for value in results[mode]["values"]] + min_time = min(all_values) + max_time = max(all_values) + padding = max(max_time - min_time, max_time * 0.15, 5.0) + ax.set_ylim(max(0.0, min_time - padding * 0.18), max_time + padding * 0.42) + + for x, mode in enumerate(MODES): + values = results[mode]["values"] + mean_time = results[mode]["mean"] + color = MODE_COLORS[mode] + jitter = np.linspace(-0.18, 0.18, len(values)) + + ax.scatter( + x + jitter, + values, + s=95, + color=color, + alpha=0.78, + edgecolors="white", + linewidths=1.2, + zorder=3, + ) + ax.vlines( + x, + results[mode]["min"], + results[mode]["max"], + color=color, + alpha=0.35, + linewidth=3, + ) + ax.scatter( + [x], + [mean_time], + marker="D", + s=185, + color="#111111", + edgecolors="white", + linewidths=1.6, + ) + ax.hlines(mean_time, x - 0.22, x + 0.22, color="#111111", linewidth=2.6) + + ax.text( + x, + results[mode]["max"] + padding * 0.06, + f"mean {mean_time:.1f} ms\n{results[mode]['speedup']:.2f}x vs seq", + ha="center", + va="bottom", + fontsize=13, + fontweight="bold", + ) + + ax.grid(axis="y", color="#d9d2c7", linewidth=1.0, alpha=0.85) + ax.set_axisbelow(True) + ax.set_xticks(range(len(MODES))) + ax.set_xticklabels([MODE_NAMES[mode] for mode in MODES], fontsize=14, fontweight="bold") + ax.set_ylabel("Pipeline processing time, ms", fontsize=16, fontweight="bold") + ax.set_xlabel("Convolution runner", fontsize=16, fontweight="bold") + ax.tick_params(axis="y", labelsize=13) + ax.spines["top"].set_visible(False) + ax.spines["right"].set_visible(False) + ax.spines["left"].set_color("#7a746b") + ax.spines["bottom"].set_color("#7a746b") + ax.axhline( + results["seq"]["mean"], + color=MODE_COLORS["seq"], + linestyle="--", + linewidth=1.8, + alpha=0.55, + ) + + fig.suptitle( + f"Thread-pool image pipeline | {image_count} images | {CASE_TITLE}", + fontsize=20, + fontweight="bold", + y=0.97, + ) + ax.set_title(f"{RUNS} launches per runner", fontsize=14, pad=18) + + output_path = BENCHMARK_DIR / f"pipeline_{CASE_NAME}_convolution_runner_benchmark.png" + fig.tight_layout(rect=(0, 0, 1, 0.93)) + fig.savefig(output_path, bbox_inches="tight") + plt.close(fig) + return output_path + + +def main(): + BENCHMARK_DIR.mkdir(exist_ok=True) + PROCESSED_DIR.mkdir(exist_ok=True) + + images = get_input_images() + if len(images) <= 1: + raise RuntimeError("pipeline benchmark needs more than one 4K input image") + + print("pipeline images:", ", ".join(path.name for path in images)) + results = run_benchmark(images) + plot_path = draw_plot(results, len(images)) + + for mode in MODES: + data = results[mode] + print( + f"{mode}: mean={data['mean']:.3f} ms, " + f"min={data['min']:.3f} ms, max={data['max']:.3f} ms, " + f"speedup={data['speedup']:.2f}x" + ) + + print(f"plot: {plot_path}") + + +if __name__ == "__main__": + main() diff --git a/scripts/benchmark_readme.py b/scripts/benchmark_readme.py new file mode 100755 index 0000000..b3545ba --- /dev/null +++ b/scripts/benchmark_readme.py @@ -0,0 +1,351 @@ +#!/usr/bin/env python3 + +import json +import os +import platform +import re +import statistics +import subprocess +from pathlib import Path + +os.environ.setdefault("MPLCONFIGDIR", "/tmp/image_conversation_matplotlib") + +import matplotlib + +matplotlib.use("Agg") + +import matplotlib.pyplot as plt +import numpy as np +from PIL import Image + + +ROOT = Path(__file__).resolve().parent.parent +INPUT_DIR = ROOT / "input" +BENCHMARK_DIR = ROOT / "benchmarks" +OUTPUT_DIR = Path("/tmp/image_conversation_benchmark_outputs") +APP = ROOT / "build" / "bin" / "app" + +RUNS = 10 +MODES = ["seq", "rows", "cols", "pixels", "grid"] +IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png"} +TIME_PATTERN = re.compile(r"processing time:\s*([0-9]+(?:\.[0-9]+)?)\s*ms") + +CASE_NAME = "gauss_5x5_then_sharpen_3x3" +CASE_TITLE = "gauss 5x5 -> sharpen 3x3" +FILTERS = [ + ("gauss", 5, 5, None), + ("sharpen", 3, 3, None), +] + +SINGLE_IMAGES = [ + "satoru.jpg", + "sunshine.jpg", + "stariy_bog.png", + "musashi.jpg", + "sea.png", +] + +MODE_NAMES = { + "seq": "Sequential", + "rows": "Parallel rows", + "cols": "Parallel cols", + "pixels": "Parallel pixels", + "grid": "Parallel grid", +} + +MODE_COLORS = { + "seq": "#BC3C28", + "rows": "#0072B5", + "cols": "#2E8B57", + "pixels": "#8A52A1", + "grid": "#C58B00", +} + + +def available_thread_count(): + if hasattr(os, "sched_getaffinity"): + return len(os.sched_getaffinity(0)) + + return os.cpu_count() or 1 + + +def benchmark_env(): + env = os.environ.copy() + env.setdefault("OMP_NUM_THREADS", str(available_thread_count())) + return env + + +def image_info(path): + with Image.open(path) as image: + width, height = image.size + + return { + "name": path.name, + "path": str(path.relative_to(ROOT)), + "stem": path.stem, + "width": width, + "height": height, + "megapixels": width * height / 1_000_000, + } + + +def get_single_images(): + return [image_info(INPUT_DIR / name) for name in SINGLE_IMAGES] + + +def get_pipeline_images(): + images = [] + + for path in sorted(INPUT_DIR.iterdir()): + if path.suffix.lower() not in IMAGE_EXTENSIONS: + continue + if "3840x2160" not in path.name: + continue + + info = image_info(path) + if info["width"] >= 3840 and info["height"] >= 2160: + images.append(info) + + if len(images) < 10: + raise RuntimeError("pipeline benchmark needs at least ten 4K input images") + + return images[:10] + + +def add_filter_args(command): + for name, height, width, filter_type in FILTERS: + command += ["-f", name, "-h", str(height), "-w", str(width)] + if filter_type is not None: + command += ["-t", filter_type] + + +def add_mode_args(command, mode): + if mode == "seq": + command += ["-s"] + else: + command += ["-p", mode] + + +def build_single_command(image, mode): + output_path = OUTPUT_DIR / "single" / f"{image['stem']}_{mode}.png" + command = [ + str(APP), + "-i", + str(ROOT / image["path"]), + "-o", + str(output_path), + ] + add_filter_args(command) + add_mode_args(command, mode) + return command + + +def build_pipeline_command(images, mode): + command = [str(APP)] + + for index, image in enumerate(images, start=1): + output_path = OUTPUT_DIR / "pipeline" / f"image_{index:02d}_{mode}.png" + command += ["-i", str(ROOT / image["path"]), "-o", str(output_path)] + + add_filter_args(command) + add_mode_args(command, mode) + return command + + +def run_program(command, env): + completed = subprocess.run(command, check=True, capture_output=True, text=True, env=env) + match = TIME_PATTERN.search(completed.stdout) + if match is None: + raise RuntimeError(f"application output does not contain processing time: {completed.stdout}") + + return float(match.group(1)) + + +def summarize_runs(values, seq_mean): + mean = statistics.fmean(values) + return { + "runs_ms": values, + "mean_ms": mean, + "min_ms": min(values), + "max_ms": max(values), + "speedup_vs_seq": seq_mean / mean, + } + + +def run_mode_benchmark(command_builder, env, progress_prefix): + raw_results = {} + + for mode in MODES: + values = [] + + for run_number in range(1, RUNS + 1): + value = run_program(command_builder(mode), env) + values.append(value) + print(f"{progress_prefix} | {mode} | run {run_number}/{RUNS}: {value:.3f} ms", flush=True) + + raw_results[mode] = values + + seq_mean = statistics.fmean(raw_results["seq"]) + return {mode: summarize_runs(values, seq_mean) for mode, values in raw_results.items()} + + +def draw_plot(title, subtitle, output_path, results): + fig, ax = plt.subplots(figsize=(16, 10), dpi=180) + fig.patch.set_facecolor("#f6f3ee") + ax.set_facecolor("#fffdfa") + + all_values = [value for mode in MODES for value in results[mode]["runs_ms"]] + min_time = min(all_values) + max_time = max(all_values) + padding = max(max_time - min_time, max_time * 0.15, 5.0) + ax.set_ylim(max(0.0, min_time - padding * 0.18), max_time + padding * 0.42) + + for x, mode in enumerate(MODES): + values = results[mode]["runs_ms"] + mean_time = results[mode]["mean_ms"] + color = MODE_COLORS[mode] + jitter = np.linspace(-0.18, 0.18, len(values)) + + ax.scatter( + x + jitter, + values, + s=95, + color=color, + alpha=0.78, + edgecolors="white", + linewidths=1.2, + zorder=3, + ) + ax.vlines( + x, + results[mode]["min_ms"], + results[mode]["max_ms"], + color=color, + alpha=0.35, + linewidth=3, + ) + ax.scatter( + [x], + [mean_time], + marker="D", + s=185, + color="#111111", + edgecolors="white", + linewidths=1.6, + ) + ax.hlines(mean_time, x - 0.22, x + 0.22, color="#111111", linewidth=2.6) + + ax.text( + x, + results[mode]["max_ms"] + padding * 0.06, + f"mean {mean_time:.1f} ms\n{results[mode]['speedup_vs_seq']:.2f}x vs seq", + ha="center", + va="bottom", + fontsize=13, + fontweight="bold", + ) + + ax.grid(axis="y", color="#d9d2c7", linewidth=1.0, alpha=0.85) + ax.set_axisbelow(True) + ax.set_xticks(range(len(MODES))) + ax.set_xticklabels([MODE_NAMES[mode] for mode in MODES], fontsize=14, fontweight="bold") + ax.set_ylabel("Processing time, ms", fontsize=16, fontweight="bold") + ax.set_xlabel("Convolution runner", fontsize=16, fontweight="bold") + ax.tick_params(axis="y", labelsize=13) + ax.spines["top"].set_visible(False) + ax.spines["right"].set_visible(False) + ax.spines["left"].set_color("#7a746b") + ax.spines["bottom"].set_color("#7a746b") + ax.axhline( + results["seq"]["mean_ms"], + color=MODE_COLORS["seq"], + linestyle="--", + linewidth=1.8, + alpha=0.55, + ) + + fig.suptitle(title, fontsize=20, fontweight="bold", y=0.97) + ax.set_title(subtitle, fontsize=14, pad=18) + + fig.tight_layout(rect=(0, 0, 1, 0.93)) + fig.savefig(output_path, bbox_inches="tight") + plt.close(fig) + + +def run_single_benchmarks(env): + results = [] + + for image in get_single_images(): + benchmark = run_mode_benchmark( + lambda mode, current=image: build_single_command(current, mode), + env, + f"single {image['name']}", + ) + plot_path = BENCHMARK_DIR / f"readme_single_{image['stem']}_{CASE_NAME}_benchmark.png" + draw_plot( + f"{image['name']} | {image['width']}x{image['height']} px | {CASE_TITLE}", + f"{RUNS} launches per runner", + plot_path, + benchmark, + ) + results.append({"image": image, "results": benchmark, "plot_path": str(plot_path.relative_to(ROOT))}) + + return results + + +def run_pipeline_benchmark(env): + images = get_pipeline_images() + benchmark = run_mode_benchmark( + lambda mode: build_pipeline_command(images, mode), + env, + "pipeline 10x4K", + ) + plot_path = BENCHMARK_DIR / f"readme_pipeline_{CASE_NAME}_benchmark.png" + draw_plot( + f"Pipeline | 10 images | {CASE_TITLE}", + f"{RUNS} launches per runner", + plot_path, + benchmark, + ) + + return {"images": images, "results": benchmark, "plot_path": str(plot_path.relative_to(ROOT))} + + +def write_results(data): + output_path = BENCHMARK_DIR / "readme_benchmark_results.json" + with output_path.open("w", encoding="utf-8") as file: + json.dump(data, file, indent=2) + file.write("\n") + + return output_path + + +def main(): + if not APP.exists(): + raise RuntimeError("build/bin/app does not exist; build the app before benchmarking") + + BENCHMARK_DIR.mkdir(exist_ok=True) + (OUTPUT_DIR / "single").mkdir(parents=True, exist_ok=True) + (OUTPUT_DIR / "pipeline").mkdir(parents=True, exist_ok=True) + + env = benchmark_env() + data = { + "case": CASE_TITLE, + "runs": RUNS, + "modes": MODES, + "mode_names": MODE_NAMES, + "environment": { + "system": platform.platform(), + "machine": platform.machine(), + "omp_num_threads": env["OMP_NUM_THREADS"], + }, + "single_images": run_single_benchmarks(env), + "pipeline": run_pipeline_benchmark(env), + } + + output_path = write_results(data) + print(f"results: {output_path.relative_to(ROOT)}", flush=True) + + +if __name__ == "__main__": + main() diff --git a/src/app.c b/src/app.c new file mode 100644 index 0000000..f78daf0 --- /dev/null +++ b/src/app.c @@ -0,0 +1,86 @@ +#include +#include +#include +#include +#include +#include "cli_args.h" + +#include +#include +#include + +#define MAX_ERR_LEN 32 + +static double elapsed_ms(const struct timespec *start, const struct timespec *end) { + double s = (double)(end->tv_sec - start->tv_sec) * 1000.0; + double ns = (double)(end->tv_nsec - start->tv_nsec) / 1000000.0; + return s + ns; +} + +static image_convolution_runner_t select_runner(execution_mode_t mode) { + switch (mode) { + case EXECUTION_MODE_SEQ: return sequential_convolution; + case EXECUTION_MODE_ROWS: return parallel_convolution_rows; + case EXECUTION_MODE_PIXELS: return parallel_convolution_pixels; + case EXECUTION_MODE_COLS: return parallel_convolution_cols; + case EXECUTION_MODE_GRID: return parallel_convolution_rectangle; + case EXECUTION_MODE_GPU: return gpu_convolution; + case EXECUTION_MODE_HYBRID: return sequential_convolution; + default: return NULL; + } +} + +static void fill_request(image_pipeline_request_t *pipe_req, const cli_request_t *cli_req, size_t idx, image_convolution_runner_t runner) { + pipe_req->input_path = cli_req->images[idx].input_path; + pipe_req->output_path = cli_req->images[idx].output_path; + pipe_req->filter_count = cli_req->filter_count; + pipe_req->run_convolution = runner; + + for (size_t i = 0; i < cli_req->filter_count; ++i) { + pipe_req->filters[i] = (filter_request_t){ + .kind = cli_req->filters[i].kind, + .width = cli_req->filters[i].width, + .height = cli_req->filters[i].height, + .direction = cli_req->filters[i].direction, + .border_mode = cli_req->filters[i].border_mode, + }; + } +} + +int main(int argc, char **argv) { + cli_request_t req; + char err_msg[MAX_ERR_LEN]; + cli_parse_status_t status = cli_parse_args(argc, argv, &req, err_msg, sizeof(err_msg)); + + if (status == CLI_PARSE_HELP) return 0; + if (status != CLI_PARSE_OK) { + if (err_msg[0] != '\0') puts(err_msg); + return -1; + } + + image_convolution_runner_t base_runner = select_runner(req.mode); + if (!base_runner) { + cli_request_destroy(&req); + return -1; + } + + image_pipeline_request_t *pipe_reqs = malloc(sizeof(*pipe_reqs) * req.image_count); + for (size_t i = 0; i < req.image_count; ++i) { + image_convolution_runner_t r = base_runner; + if (req.mode == EXECUTION_MODE_HYBRID) { + r = (i % 2 == 0) ? parallel_convolution_rows : gpu_convolution; + } + fill_request(&pipe_reqs[i], &req, i, r); + } + + struct timespec start, end; + timespec_get(&start, TIME_UTC); + int res = image_pipeline_run(pipe_reqs, req.image_count); + timespec_get(&end, TIME_UTC); + + printf("processing time: %.3f ms\n", elapsed_ms(&start, &end)); + + free(pipe_reqs); + cli_request_destroy(&req); + return res == 0 ? 0 : -1; +} diff --git a/src/app/execution_config.h b/src/app/execution_config.h new file mode 100644 index 0000000..e60bddc --- /dev/null +++ b/src/app/execution_config.h @@ -0,0 +1,29 @@ +#pragma once + +#include + +typedef enum execution_mode { + EXECUTION_MODE_SEQ = 0, + EXECUTION_MODE_ROWS, + EXECUTION_MODE_PIXELS, + EXECUTION_MODE_COLS, + EXECUTION_MODE_GRID, + EXECUTION_MODE_GPU, + EXECUTION_MODE_HYBRID, +} execution_mode_t; + +typedef struct execution_config { + execution_mode_t mode; + size_t threads; + size_t grid_rows; + size_t grid_cols; +} execution_config_t; + +static inline execution_config_t make_execution_config(execution_mode_t mode, size_t threads, size_t grid_rows, size_t grid_cols) { + return (execution_config_t){ + .mode = mode, + .threads = threads, + .grid_rows = grid_rows, + .grid_cols = grid_cols, + }; +} diff --git a/src/cli_args.c b/src/cli_args.c new file mode 100644 index 0000000..94d2fbc --- /dev/null +++ b/src/cli_args.c @@ -0,0 +1,159 @@ +#include "cli_args.h" +#include +#include +#include +#include +#include + +#define INIT_IMG_CAP 4 +#define MIN_ARGS 12 + +static void cli_set_invalid(char *err, size_t size) { + if (err && size > 0) snprintf(err, size, "invalid"); +} + +static cli_parse_status_t cli_invalid(char *err, size_t size) { + cli_set_invalid(err, size); + return CLI_PARSE_ERROR; +} + +static bool parse_size(const char *txt, size_t *val) { + if (!txt || !val || *txt == '\0') return false; + char *end = NULL; + unsigned long p = strtoul(txt, &end, 10); + if (*end != '\0' || p == 0) return false; + *val = (size_t)p; + return true; +} + +static bool parse_filter_kind(const char *txt, filter_kind_t *k) { + if (strcmp(txt, "blur") == 0) *k = FILTER_KIND_BLUR; + else if (strcmp(txt, "mean") == 0) *k = FILTER_KIND_MEAN; + else if (strcmp(txt, "gauss") == 0) *k = FILTER_KIND_GAUSSIAN_BLUR; + else if (strcmp(txt, "motion") == 0) *k = FILTER_KIND_MOTION_BLUR; + else if (strcmp(txt, "edge") == 0) *k = FILTER_KIND_EDGE_DETECT; + else if (strcmp(txt, "sharpen") == 0) *k = FILTER_KIND_SHARPEN; + else if (strcmp(txt, "emboss") == 0) *k = FILTER_KIND_EMBOSS; + else if (strcmp(txt, "median") == 0) *k = FILTER_KIND_MEDIAN; + else return false; + return true; +} + +static bool parse_direction(const char *txt, filter_direction_t *d) { + if (strcmp(txt, "horizontal") == 0) *d = FILTER_DIRECTION_HORIZONTAL; + else if (strcmp(txt, "vertical") == 0) *d = FILTER_DIRECTION_VERTICAL; + else if (strcmp(txt, "diagonal") == 0) *d = FILTER_DIRECTION_DIAGONAL_45; + else if (strcmp(txt, "omni") == 0) *d = FILTER_DIRECTION_OMNIDIRECTIONAL; + else return false; + return true; +} + +static bool parse_mode(const char *txt, execution_mode_t *m) { + if (strcmp(txt, "cols") == 0) *m = EXECUTION_MODE_COLS; + else if (strcmp(txt, "rows") == 0 || strcmp(txt, "raws") == 0) *m = EXECUTION_MODE_ROWS; + else if (strcmp(txt, "pixels") == 0) *m = EXECUTION_MODE_PIXELS; + else if (strcmp(txt, "grid") == 0 || strcmp(txt, "rectangle") == 0 || strcmp(txt, "random") == 0) *m = EXECUTION_MODE_GRID; + else if (strcmp(txt, "gpu") == 0) *m = EXECUTION_MODE_GPU; + else if (strcmp(txt, "hybrid") == 0) *m = EXECUTION_MODE_HYBRID; + else return false; + return true; +} + +void cli_request_destroy(cli_request_t *req) { + if (req) free(req->images); +} + +static bool add_image(cli_request_t *req, const char *in, const char *out) { + if (!req || !in || !out) return false; + if (req->image_count == req->image_capacity) { + size_t cap = req->image_capacity == 0 ? INIT_IMG_CAP : req->image_capacity * 2; + cli_image_io_t *next = realloc(req->images, sizeof(*req->images) * cap); + if (!next) return false; + req->images = next; + req->image_capacity = cap; + } + req->images[req->image_count++] = (cli_image_io_t){.input_path = in, .output_path = out}; + return true; +} + +static bool parse_filter_spec(int argc, char **argv, int *idx, cli_filter_spec_t *f) { + if (*idx + 5 >= argc) return false; + if (strcmp(argv[*idx], "-f") != 0 || strcmp(argv[*idx + 2], "-h") != 0 || strcmp(argv[*idx + 4], "-w") != 0) return false; + if (!parse_filter_kind(argv[*idx + 1], &f->kind) || !parse_size(argv[*idx + 3], &f->height) || !parse_size(argv[*idx + 5], &f->width)) return false; + *idx += 6; + if (*idx + 1 < argc && strcmp(argv[*idx], "-t") == 0) { + if (!parse_direction(argv[*idx + 1], &f->direction)) return false; + *idx += 2; + } + return true; +} + +cli_parse_status_t cli_parse_args(int argc, char **argv, cli_request_t *req, char *err, size_t err_size) { + if (!req || !argv) return cli_invalid(err, err_size); + memset(req, 0, sizeof(*req)); + req->mode = EXECUTION_MODE_SEQ; + for (size_t i = 0; i < CLI_MAX_FILTERS; ++i) { + req->filters[i].direction = FILTER_DIRECTION_NONE; + req->filters[i].border_mode = FILTER_BORDER_WRAP; + } + + if (argc == 2 && strcmp(argv[1], "--help") == 0) { + cli_print_help(stdout, argv[0]); + return CLI_PARSE_HELP; + } + + if (argc < MIN_ARGS) return cli_invalid(err, err_size); + + int idx = 1; + while (idx < argc && strcmp(argv[idx], "-i") == 0) { + if (idx + 3 >= argc || strcmp(argv[idx + 2], "-o") != 0) break; + if (!add_image(req, argv[idx + 1], argv[idx + 3])) break; + idx += 4; + } + + if (req->image_count == 0) { + cli_request_destroy(req); + return cli_invalid(err, err_size); + } + + if (!parse_filter_spec(argc, argv, &idx, &req->filters[0])) { + cli_request_destroy(req); + return cli_invalid(err, err_size); + } + req->filter_count = 1; + + if (idx < argc && strcmp(argv[idx], "-f") == 0) { + if (!parse_filter_spec(argc, argv, &idx, &req->filters[1])) { + cli_request_destroy(req); + return cli_invalid(err, err_size); + } + req->filter_count = 2; + } + + if (idx >= argc) { + cli_request_destroy(req); + return cli_invalid(err, err_size); + } + + if (strcmp(argv[idx], "-s") == 0 && idx + 1 == argc) { + req->mode = EXECUTION_MODE_SEQ; + } else if (strcmp(argv[idx], "-p") == 0 && idx + 2 == argc) { + if (!parse_mode(argv[idx + 1], &req->mode)) { + cli_request_destroy(req); + return cli_invalid(err, err_size); + } + } else { + cli_request_destroy(req); + return cli_invalid(err, err_size); + } + + return CLI_PARSE_OK; +} + +void cli_print_help(FILE *s, const char *prog) { + const char *n = prog ? prog : "main"; + fprintf(s, "Usage:\n" + " %s (-i -o )+ -f -h -w [-t ] -s\n" + " %s (-i -o )+ -f -h -w [-t ] -p \n" + "Modes: cols, rows, pixels, grid, gpu, hybrid\n", n, n); +} diff --git a/src/cli_args.h b/src/cli_args.h new file mode 100644 index 0000000..d68b1dd --- /dev/null +++ b/src/cli_args.h @@ -0,0 +1,48 @@ +#pragma once + +#include +#include + +#include +#include + +#define CLI_MAX_FILTERS 2U + +typedef enum cli_parse_status { + CLI_PARSE_OK = 0, + CLI_PARSE_HELP, + CLI_PARSE_ERROR, +} cli_parse_status_t; + +typedef struct cli_filter_spec { + filter_kind_t kind; + size_t width; + size_t height; + filter_direction_t direction; + filter_border_mode_t border_mode; +} cli_filter_spec_t; + +typedef struct cli_image_io { + const char *input_path; + const char *output_path; +} cli_image_io_t; + +typedef struct cli_request { + cli_image_io_t *images; + size_t image_count; + size_t image_capacity; + + execution_mode_t mode; + cli_filter_spec_t filters[CLI_MAX_FILTERS]; + size_t filter_count; +} cli_request_t; + +cli_parse_status_t cli_parse_args(int argc, + char **argv, + cli_request_t *request, + char *error_message, + size_t error_message_size); + +void cli_request_destroy(cli_request_t *request); + +void cli_print_help(FILE *stream, const char *program_name); diff --git a/src/convolution/convolution.c b/src/convolution/convolution.c new file mode 100644 index 0000000..4b7bea9 --- /dev/null +++ b/src/convolution/convolution.c @@ -0,0 +1,163 @@ +#include "convolution.h" +#include + +#include +#include +#include + +static int validate_convolution_input(const filter_t *filter, + const image_view_t *image_view) { + if (filter == NULL || image_view == NULL || image_view->data == NULL) { + return -1; + } + if (!filter_is_convolution(filter) || !filter_has_explicit_kernel(filter)) { + return -1; + } + if (filter->width == 0U || filter->height == 0U) { + return -1; + } + if (image_view->width == 0U || image_view->height == 0U || + image_view->channels == 0U) { + return -1; + } + if (image_view->width > (SIZE_MAX / image_view->channels)) { + return -1; + } + if (image_view->stride < image_view->width * image_view->channels) { + return -1; + } + if (image_view->height > (SIZE_MAX / image_view->stride)) { + return -1; + } + + return 0; +} + +static int convolution_context_is_valid(const convolution_context_t *context) { + return context != NULL && context->filter != NULL && + context->source != NULL && context->destination != NULL && + context->width != 0U && context->height != 0U && + context->stride != 0U && context->channels != 0U; +} + +static void convolution_apply_pixel_unchecked( + const convolution_context_t *context, size_t y, size_t x) { + const filter_t *filter = context->filter; + unsigned char *dst_pixel = + context->destination + y * context->stride + x * context->channels; + + for (size_t channel = 0; channel < context->channels; ++channel) { + if (context->channels == 4U && channel == 3U) { + dst_pixel[channel] = + context->source[y * context->stride + x * context->channels + channel]; + continue; + } + + double sum = 0.0; + + for (size_t filter_y = 0; filter_y < filter->height; ++filter_y) { + for (size_t filter_x = 0; filter_x < filter->width; ++filter_x) { + const long src_x = + (long)x - (long)(filter->width / 2U) + (long)filter_x; + const long src_y = + (long)y - (long)(filter->height / 2U) + (long)filter_y; + + const size_t image_x = + resolve_index(src_x, context->width, filter->border_mode); + const size_t image_y = + resolve_index(src_y, context->height, filter->border_mode); + + const unsigned char *src_pixel = context->source + + image_y * context->stride + + image_x * context->channels; + const double kernel_value = + filter->kernel[filter_y * filter->width + filter_x]; + + sum += (double)src_pixel[channel] * kernel_value; + } + } + + dst_pixel[channel] = clamp_to_u8(filter->factor * sum + filter->bias); + } +} + +int convolution_run(const filter_t *filter, + image_view_t *image_view, + convolution_executor_t executor) { + if (executor == NULL || validate_convolution_input(filter, image_view) != 0) { + return -1; + } + + const size_t buffer_size = image_view->height * image_view->stride; + unsigned char *source_copy = (unsigned char *)malloc(buffer_size); + if (source_copy == NULL) { + return -1; + } + + memcpy(source_copy, image_view->data, buffer_size); + + const convolution_context_t context = { + .filter = filter, + .source = source_copy, + .destination = image_view->data, + .height = image_view->height, + .width = image_view->width, + .stride = image_view->stride, + .channels = image_view->channels, + }; + + const int result = executor(&context); + free(source_copy); + return result; +} + +int convolution_apply_pixel(const convolution_context_t *context, + size_t y, + size_t x) { + if (!convolution_context_is_valid(context) || y >= context->height || + x >= context->width) { + return -1; + } + + convolution_apply_pixel_unchecked(context, y, x); + return 0; +} + +int convolution_apply_rect(const convolution_context_t *context, + size_t y_begin, + size_t y_end, + size_t x_begin, + size_t x_end) { + if (!convolution_context_is_valid(context) || y_begin > y_end || + x_begin > x_end || y_end > context->height || x_end > context->width) { + return -1; + } + + for (size_t y = y_begin; y < y_end; ++y) { + for (size_t x = x_begin; x < x_end; ++x) { + convolution_apply_pixel_unchecked(context, y, x); + } + } + + return 0; +} + +int convolution_apply_rows(const convolution_context_t *context, + size_t y_begin, + size_t y_end) { + if (!convolution_context_is_valid(context)) { + return -1; + } + + return convolution_apply_rect(context, y_begin, y_end, 0U, context->width); +} + +int convolution_apply_cols(const convolution_context_t *context, + size_t x_begin, + size_t x_end) { + if (!convolution_context_is_valid(context)) { + return -1; + } + + return convolution_apply_rect(context, 0U, context->height, x_begin, x_end); +} diff --git a/src/convolution/convolution.h b/src/convolution/convolution.h new file mode 100644 index 0000000..f8689dd --- /dev/null +++ b/src/convolution/convolution.h @@ -0,0 +1,40 @@ +#pragma once + +#include + +#include +#include + +typedef struct convolution_context { + const filter_t *filter; + const unsigned char *source; + unsigned char *destination; + size_t height; + size_t width; + size_t stride; + size_t channels; +} convolution_context_t; + +typedef int (*convolution_executor_t)(const convolution_context_t *context); + +int convolution_run(const filter_t *filter, + image_view_t *image_view, + convolution_executor_t executor); + +int convolution_apply_pixel(const convolution_context_t *context, + size_t y, + size_t x); + +int convolution_apply_rect(const convolution_context_t *context, + size_t y_begin, + size_t y_end, + size_t x_begin, + size_t x_end); + +int convolution_apply_rows(const convolution_context_t *context, + size_t y_begin, + size_t y_end); + +int convolution_apply_cols(const convolution_context_t *context, + size_t x_begin, + size_t x_end); diff --git a/src/filters/blur_filter/blur_filter.c b/src/filters/blur_filter/blur_filter.c new file mode 100644 index 0000000..2dd8817 --- /dev/null +++ b/src/filters/blur_filter/blur_filter.c @@ -0,0 +1,60 @@ +#include "blur_filter.h" + +// clang-format off +static const double blur_kernel_3x3[] = { + 0.0, 0.2, 0.0, + 0.2, 0.2, 0.2, + 0.0, 0.2, 0.0 +}; + +static const double blur_factor_3x3 = 1.0; +static const double blur_bias_3x3 = 0.0; + +static const double blur_kernel_5x5[] = { + 0.0, 0.0, 1.0, 0.0, 0.0, + 0.0, 1.0, 1.0, 1.0, 0.0, + 1.0, 1.0, 1.0, 1.0, 1.0, + 0.0, 1.0, 1.0, 1.0, 0.0, + 0.0, 0.0, 1.0, 0.0, 0.0, +}; + +static const double blur_factor_5x5 = 1.0 / 13.0; +static const double blur_bias_5x5 = 0.0; +// clang-format on + +filter_status_t +init_blur_filter(filter_t *filter, size_t width, size_t height) { + + if (!filter) { + return FILTER_STATUS_NULL_POINTER; + } + if (width != height) { + return FILTER_STATUS_UNSUPPORTED_SIZE; + } + switch (width) { + case 3: + *filter = make_convolution_filter(FILTER_KIND_BLUR, + FILTER_CATEGORY_SMOOTHING, + FILTER_DIRECTION_NONE, + FILTER_BORDER_WRAP, + blur_kernel_3x3, + blur_factor_3x3, + blur_bias_3x3, + width, + height); + return FILTER_STATUS_OK; + case 5: + *filter = make_convolution_filter(FILTER_KIND_BLUR, + FILTER_CATEGORY_SMOOTHING, + FILTER_DIRECTION_NONE, + FILTER_BORDER_WRAP, + blur_kernel_5x5, + blur_factor_5x5, + blur_bias_5x5, + width, + height); + return FILTER_STATUS_OK; + default: + return FILTER_STATUS_UNSUPPORTED_SIZE; + } +} diff --git a/src/filters/blur_filter/blur_filter.h b/src/filters/blur_filter/blur_filter.h new file mode 100644 index 0000000..9ed1bd5 --- /dev/null +++ b/src/filters/blur_filter/blur_filter.h @@ -0,0 +1,5 @@ +#pragma once + +#include + +filter_status_t init_blur_filter(filter_t *filter, size_t width, size_t height); diff --git a/src/filters/emboss_filter/emboss_filter.c b/src/filters/emboss_filter/emboss_filter.c new file mode 100644 index 0000000..dabc9a8 --- /dev/null +++ b/src/filters/emboss_filter/emboss_filter.c @@ -0,0 +1,71 @@ +#include "emboss_filter.h" + +// clang-format off +static const double emboss_kernel_3x3[] = { + -1, -1, 0, + -1, 0, 1, + 0, 1, 1, +}; + +static const double emboss_factor_3x3 = 1.0; +static const double emboss_bias_3x3 = 128.0; + +static const double emboss_kernel_5x5[] = { + -1, -1, -1, -1, 0, + -1, -1, -1, 0, 1, + -1, -1, 0, 1, 1, + -1, 0, 1, 1, 1, + 0, 1, 1, 1, 1, +}; + +static const double emboss_factor_5x5 = 1.0; +static const double emboss_bias_5x5 = 128.0; +// clang-format on + +filter_status_t init_emboss_filter(filter_t *filter, + size_t width, + size_t height, + filter_direction_t direction) { + if (!filter) { + return FILTER_STATUS_NULL_POINTER; + } + + if (direction == FILTER_DIRECTION_NONE) { + direction = FILTER_DIRECTION_DIAGONAL_45; + } + + if (direction != FILTER_DIRECTION_DIAGONAL_45) { + return FILTER_STATUS_UNSUPPORTED_DIRECTION; + } + + if (width != height) { + return FILTER_STATUS_UNSUPPORTED_SIZE; + } + + switch (width) { + case 3: + *filter = make_convolution_filter(FILTER_KIND_EMBOSS, + FILTER_CATEGORY_EDGE_ENHANCEMENT, + FILTER_DIRECTION_DIAGONAL_45, + FILTER_BORDER_WRAP, + emboss_kernel_3x3, + emboss_factor_3x3, + emboss_bias_3x3, + width, + height); + return FILTER_STATUS_OK; + case 5: + *filter = make_convolution_filter(FILTER_KIND_EMBOSS, + FILTER_CATEGORY_EDGE_ENHANCEMENT, + FILTER_DIRECTION_DIAGONAL_45, + FILTER_BORDER_WRAP, + emboss_kernel_5x5, + emboss_factor_5x5, + emboss_bias_5x5, + width, + height); + return FILTER_STATUS_OK; + default: + return FILTER_STATUS_UNSUPPORTED_SIZE; + } +} diff --git a/src/filters/emboss_filter/emboss_filter.h b/src/filters/emboss_filter/emboss_filter.h new file mode 100644 index 0000000..25e59f0 --- /dev/null +++ b/src/filters/emboss_filter/emboss_filter.h @@ -0,0 +1,8 @@ +#pragma once + +#include + +filter_status_t init_emboss_filter(filter_t *filter, + size_t width, + size_t height, + filter_direction_t direction); diff --git a/src/filters/filter.c b/src/filters/filter.c new file mode 100644 index 0000000..9d73a64 --- /dev/null +++ b/src/filters/filter.c @@ -0,0 +1,75 @@ +#include "filter.h" + +#include "blur_filter/blur_filter.h" +#include "emboss_filter/emboss_filter.h" +#include "find_edges_filter/find_edges_filter.h" +#include "gauss_blur_filter/gauss_blur_filter.h" +#include "mean_filter/mean_filter.h" +#include "median_filter/median_filter.h" +#include "motion_blur_filter/motion_blur_filter.h" +#include "sharpen_filter/sharpen_filter.h" + +filter_status_t filter_init_builtin(filter_t *filter, + const filter_request_t *request) { + filter_status_t status = FILTER_STATUS_UNSUPPORTED_KIND; + + if (!filter || !request) { + return FILTER_STATUS_NULL_POINTER; + } + + switch (request->kind) { + case FILTER_KIND_BLUR: + if (request->direction != FILTER_DIRECTION_NONE) { + return FILTER_STATUS_UNSUPPORTED_DIRECTION; + } + status = init_blur_filter(filter, request->width, request->height); + break; + case FILTER_KIND_MEAN: + if (request->direction != FILTER_DIRECTION_NONE) { + return FILTER_STATUS_UNSUPPORTED_DIRECTION; + } + status = init_mean_filter(filter, request->width, request->height); + break; + case FILTER_KIND_GAUSSIAN_BLUR: + if (request->direction != FILTER_DIRECTION_NONE) { + return FILTER_STATUS_UNSUPPORTED_DIRECTION; + } + status = init_gauss_blur_filter(filter, request->width, request->height); + break; + case FILTER_KIND_MOTION_BLUR: + if (request->direction != FILTER_DIRECTION_NONE && + request->direction != FILTER_DIRECTION_DIAGONAL_45) { + return FILTER_STATUS_UNSUPPORTED_DIRECTION; + } + status = init_motion_blur_filter(filter, request->width, request->height); + break; + case FILTER_KIND_EDGE_DETECT: + status = init_find_edges_filter( + filter, request->width, request->height, request->direction); + break; + case FILTER_KIND_SHARPEN: + if (request->direction != FILTER_DIRECTION_NONE) { + return FILTER_STATUS_UNSUPPORTED_DIRECTION; + } + status = init_sharpen_filter(filter, request->width, request->height); + break; + case FILTER_KIND_EMBOSS: + status = init_emboss_filter( + filter, request->width, request->height, request->direction); + break; + case FILTER_KIND_MEDIAN: + if (request->direction != FILTER_DIRECTION_NONE) { + return FILTER_STATUS_UNSUPPORTED_DIRECTION; + } + status = init_median_filter(filter, request->width, request->height); + break; + default: + return FILTER_STATUS_UNSUPPORTED_KIND; + } + + if (status == FILTER_STATUS_OK) { + filter->border_mode = request->border_mode; + } + + return status; +} diff --git a/src/filters/filter.h b/src/filters/filter.h new file mode 100644 index 0000000..d3b6350 --- /dev/null +++ b/src/filters/filter.h @@ -0,0 +1,153 @@ +#pragma once + +#include +#include + +typedef enum filter_status { + FILTER_STATUS_OK = 0, + FILTER_STATUS_NULL_POINTER, + FILTER_STATUS_INVALID_ARGUMENT, + FILTER_STATUS_UNSUPPORTED_SIZE, + FILTER_STATUS_UNSUPPORTED_DIRECTION, + FILTER_STATUS_UNSUPPORTED_KIND +} filter_status_t; + +typedef enum filter_category { + FILTER_CATEGORY_SMOOTHING = 0, + FILTER_CATEGORY_EDGE_DETECTION, + FILTER_CATEGORY_EDGE_ENHANCEMENT, +} filter_category_t; + +typedef enum filter_operator { + FILTER_OPERATOR_CONVOLUTION = 0, + FILTER_OPERATOR_RANK_SELECTION, +} filter_operator_t; + +typedef enum filter_kind { + FILTER_KIND_BLUR = 0, + FILTER_KIND_MEAN, + FILTER_KIND_GAUSSIAN_BLUR, + FILTER_KIND_MOTION_BLUR, + FILTER_KIND_EDGE_DETECT, + FILTER_KIND_SHARPEN, + FILTER_KIND_EMBOSS, + FILTER_KIND_MEDIAN, +} filter_kind_t; + +typedef enum filter_direction { + FILTER_DIRECTION_NONE = 0, + FILTER_DIRECTION_HORIZONTAL, + FILTER_DIRECTION_VERTICAL, + FILTER_DIRECTION_DIAGONAL_45, + FILTER_DIRECTION_OMNIDIRECTIONAL, +} filter_direction_t; + +typedef enum filter_border_mode { + FILTER_BORDER_WRAP = 0, + FILTER_BORDER_CLAMP, + FILTER_BORDER_REFLECT, +} filter_border_mode_t; + +typedef struct filter_request { + filter_kind_t kind; + size_t width; + size_t height; + filter_direction_t direction; + filter_border_mode_t border_mode; +} filter_request_t; + +typedef struct filter { + filter_category_t category; + filter_operator_t filter_operator; + filter_kind_t kind; + filter_direction_t direction; + filter_border_mode_t border_mode; + const double *kernel; + double factor; + double bias; + size_t width; + size_t height; + size_t rank_index; +} filter_t; + +static inline bool filter_size_is_odd(size_t value) { + return value != 0U && (value % 2U) == 1U; +} + +static inline size_t filter_median_rank(size_t width, size_t height) { + return (width * height) / 2U; +} + +static inline filter_request_t +make_filter_request(filter_kind_t kind, size_t width, size_t height) { + return (filter_request_t){ + .kind = kind, + .width = width, + .height = height, + .direction = FILTER_DIRECTION_NONE, + .border_mode = FILTER_BORDER_WRAP, + }; +} + +static inline filter_t make_convolution_filter(filter_kind_t kind, + filter_category_t category, + filter_direction_t direction, + filter_border_mode_t border_mode, + const double *kernel, + double factor, + double bias, + size_t width, + size_t height) { + return (filter_t){ + .category = category, + .filter_operator = FILTER_OPERATOR_CONVOLUTION, + .kind = kind, + .direction = direction, + .border_mode = border_mode, + .kernel = kernel, + .factor = factor, + .bias = bias, + .width = width, + .height = height, + .rank_index = 0U, + }; +} + +static inline filter_t make_rank_filter(filter_kind_t kind, + filter_category_t category, + filter_direction_t direction, + filter_border_mode_t border_mode, + size_t width, + size_t height, + size_t rank_index) { + return (filter_t){ + .category = category, + .filter_operator = FILTER_OPERATOR_RANK_SELECTION, + .kind = kind, + .direction = direction, + .border_mode = border_mode, + .kernel = NULL, + .factor = 0.0, + .bias = 0.0, + .width = width, + .height = height, + .rank_index = rank_index, + }; +} + +static inline bool filter_is_convolution(const filter_t *filter) { + return filter != NULL && + filter->filter_operator == FILTER_OPERATOR_CONVOLUTION; +} + +static inline bool filter_is_rank_selection(const filter_t *filter) { + return filter != NULL && + filter->filter_operator == FILTER_OPERATOR_RANK_SELECTION; +} + +static inline bool filter_has_explicit_kernel(const filter_t *filter) { + return filter_is_convolution(filter) && filter->kernel != NULL; +} + +filter_status_t filter_init_builtin(filter_t *filter, + const filter_request_t *request); diff --git a/src/filters/find_edges_filter/find_edges_filter.c b/src/filters/find_edges_filter/find_edges_filter.c new file mode 100644 index 0000000..7e79b31 --- /dev/null +++ b/src/filters/find_edges_filter/find_edges_filter.c @@ -0,0 +1,121 @@ +#include "find_edges_filter.h" + +// clang-format off +static const double find_edge_kernel_horizontal[] = { + 0, 0, -1, 0, 0, + 0, 0, -1, 0, 0, + 0, 0, 2, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, +}; + +static const double find_edge_horizontal_factor = 1.0; +static const double find_edge_horizontal_bias = 0.0; + +static const double find_edge_kernel_vertical[] = { + 0, 0, -1, 0, 0, + 0, 0, -1, 0, 0, + 0, 0, 4, 0, 0, + 0, 0, -1, 0, 0, + 0, 0, -1, 0, 0, +}; + +static const double find_edge_vertical_factor = 1.0; +static const double find_edge_vertical_bias = 0.0; + +static const double find_edge_kernel_diagonal45deg[] = { + -1, 0, 0, 0, 0, + 0, -2, 0, 0, 0, + 0, 0, 6, 0, 0, + 0, 0, 0, -2, 0, + 0, 0, 0, 0, -1, +}; + +static const double find_edge_diagonal45deg_factor = 1.0; +static const double find_edge_diagonal45deg_bias = 0.0; + + +static const double find_edge_kernel_any_direction[] = { + -1, -1, -1, + -1, 8, -1, + -1, -1, -1 +}; + +static const double find_edge_any_direction_factor = 1.0; +static const double find_edge_any_direction_bias = 0.0; + +// clang-format on + +filter_status_t init_find_edges_filter(filter_t *filter, + size_t width, + size_t height, + filter_direction_t direction) { + if (!filter) { + return FILTER_STATUS_NULL_POINTER; + } + + if (direction == FILTER_DIRECTION_NONE) { + direction = FILTER_DIRECTION_OMNIDIRECTIONAL; + } + + switch (direction) { + case FILTER_DIRECTION_HORIZONTAL: + if (width != 5 || height != 5) { + return FILTER_STATUS_UNSUPPORTED_SIZE; + } + *filter = make_convolution_filter(FILTER_KIND_EDGE_DETECT, + FILTER_CATEGORY_EDGE_DETECTION, + FILTER_DIRECTION_HORIZONTAL, + FILTER_BORDER_WRAP, + find_edge_kernel_horizontal, + find_edge_horizontal_factor, + find_edge_horizontal_bias, + width, + height); + return FILTER_STATUS_OK; + case FILTER_DIRECTION_VERTICAL: + if (width != 5 || height != 5) { + return FILTER_STATUS_UNSUPPORTED_SIZE; + } + *filter = make_convolution_filter(FILTER_KIND_EDGE_DETECT, + FILTER_CATEGORY_EDGE_DETECTION, + FILTER_DIRECTION_VERTICAL, + FILTER_BORDER_WRAP, + find_edge_kernel_vertical, + find_edge_vertical_factor, + find_edge_vertical_bias, + width, + height); + return FILTER_STATUS_OK; + case FILTER_DIRECTION_DIAGONAL_45: + if (width != 5 || height != 5) { + return FILTER_STATUS_UNSUPPORTED_SIZE; + } + *filter = make_convolution_filter(FILTER_KIND_EDGE_DETECT, + FILTER_CATEGORY_EDGE_DETECTION, + FILTER_DIRECTION_DIAGONAL_45, + FILTER_BORDER_WRAP, + find_edge_kernel_diagonal45deg, + find_edge_diagonal45deg_factor, + find_edge_diagonal45deg_bias, + width, + height); + return FILTER_STATUS_OK; + case FILTER_DIRECTION_OMNIDIRECTIONAL: + if (width != 3 || height != 3) { + return FILTER_STATUS_UNSUPPORTED_SIZE; + } + *filter = make_convolution_filter(FILTER_KIND_EDGE_DETECT, + FILTER_CATEGORY_EDGE_DETECTION, + FILTER_DIRECTION_OMNIDIRECTIONAL, + FILTER_BORDER_WRAP, + find_edge_kernel_any_direction, + find_edge_any_direction_factor, + find_edge_any_direction_bias, + width, + height); + return FILTER_STATUS_OK; + default: + return FILTER_STATUS_UNSUPPORTED_DIRECTION; + } +} diff --git a/src/filters/find_edges_filter/find_edges_filter.h b/src/filters/find_edges_filter/find_edges_filter.h new file mode 100644 index 0000000..b0866d8 --- /dev/null +++ b/src/filters/find_edges_filter/find_edges_filter.h @@ -0,0 +1,8 @@ +#pragma once + +#include + +filter_status_t init_find_edges_filter(filter_t *filter, + size_t width, + size_t height, + filter_direction_t direction); diff --git a/src/filters/gauss_blur_filter/gauss_blur_filter.c b/src/filters/gauss_blur_filter/gauss_blur_filter.c new file mode 100644 index 0000000..2f16b79 --- /dev/null +++ b/src/filters/gauss_blur_filter/gauss_blur_filter.c @@ -0,0 +1,59 @@ +#include "gauss_blur_filter.h" + +// clang-format off +static const double gauss_blur_kernel_3x3[] = { + 1, 2, 1, + 2, 4, 2, + 1, 2, 1, +}; + +static const double blur_factor_3x3 = 1.0 / 16.0; +static const double blur_bias_3x3 = 0.0; + +static const double gauss_blur_kernel_5x5[] = { + 1, 4, 6, 4, 1, + 4, 16, 24, 16, 4, + 6, 24, 36, 24, 6, + 4, 16, 24, 16, 4, + 1, 4, 6, 4, 1, +}; + +static const double blur_factor_5x5 = 1.0 / 256.0; +static const double blur_bias_5x5 = 0.0; +// clang-format on + +filter_status_t +init_gauss_blur_filter(filter_t *filter, size_t width, size_t height) { + if (!filter) { + return FILTER_STATUS_NULL_POINTER; + } + if (width != height) { + return FILTER_STATUS_UNSUPPORTED_SIZE; + } + switch (width) { + case 3: + *filter = make_convolution_filter(FILTER_KIND_GAUSSIAN_BLUR, + FILTER_CATEGORY_SMOOTHING, + FILTER_DIRECTION_NONE, + FILTER_BORDER_WRAP, + gauss_blur_kernel_3x3, + blur_factor_3x3, + blur_bias_3x3, + width, + height); + return FILTER_STATUS_OK; + case 5: + *filter = make_convolution_filter(FILTER_KIND_GAUSSIAN_BLUR, + FILTER_CATEGORY_SMOOTHING, + FILTER_DIRECTION_NONE, + FILTER_BORDER_WRAP, + gauss_blur_kernel_5x5, + blur_factor_5x5, + blur_bias_5x5, + width, + height); + return FILTER_STATUS_OK; + default: + return FILTER_STATUS_UNSUPPORTED_SIZE; + } +} diff --git a/src/filters/gauss_blur_filter/gauss_blur_filter.h b/src/filters/gauss_blur_filter/gauss_blur_filter.h new file mode 100644 index 0000000..9d61e35 --- /dev/null +++ b/src/filters/gauss_blur_filter/gauss_blur_filter.h @@ -0,0 +1,6 @@ +#pragma once + +#include + +filter_status_t +init_gauss_blur_filter(filter_t *filter, size_t width, size_t height); diff --git a/src/filters/mean_filter/mean_filter.c b/src/filters/mean_filter/mean_filter.c new file mode 100644 index 0000000..0df228f --- /dev/null +++ b/src/filters/mean_filter/mean_filter.c @@ -0,0 +1,60 @@ +#include "mean_filter.h" + +// clang-format off +static const double mean_kernel_3x3[] = { + 1, 1, 1, + 1, 1, 1, + 1, 1, 1, +}; + +static const double mean_factor_3x3 = 1.0 / 9.0; +static const double mean_bias_3x3 = 0.0; + +static const double mean_kernel_5x5[] = { + 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, +}; + +static const double mean_factor_5x5 = 1.0 / 25.0; +static const double mean_bias_5x5 = 0.0; +// clang-format on + +filter_status_t init_mean_filter(filter_t *filter, size_t width, size_t height) { + if (!filter) { + return FILTER_STATUS_NULL_POINTER; + } + + if (width != height) { + return FILTER_STATUS_UNSUPPORTED_SIZE; + } + + switch (width) { + case 3: + *filter = make_convolution_filter(FILTER_KIND_MEAN, + FILTER_CATEGORY_SMOOTHING, + FILTER_DIRECTION_NONE, + FILTER_BORDER_WRAP, + mean_kernel_3x3, + mean_factor_3x3, + mean_bias_3x3, + width, + height); + return FILTER_STATUS_OK; + case 5: + *filter = make_convolution_filter(FILTER_KIND_MEAN, + FILTER_CATEGORY_SMOOTHING, + FILTER_DIRECTION_NONE, + FILTER_BORDER_WRAP, + mean_kernel_5x5, + mean_factor_5x5, + mean_bias_5x5, + width, + height); + return FILTER_STATUS_OK; + default: + return FILTER_STATUS_UNSUPPORTED_SIZE; + } +} diff --git a/src/filters/mean_filter/mean_filter.h b/src/filters/mean_filter/mean_filter.h new file mode 100644 index 0000000..5492c79 --- /dev/null +++ b/src/filters/mean_filter/mean_filter.h @@ -0,0 +1,7 @@ +#pragma once + +#include + +filter_status_t init_mean_filter(filter_t *filter, + size_t width, + size_t height); diff --git a/src/filters/median_filter/median_filter.c b/src/filters/median_filter/median_filter.c new file mode 100644 index 0000000..b28ebac --- /dev/null +++ b/src/filters/median_filter/median_filter.c @@ -0,0 +1,22 @@ +#include "median_filter.h" + +filter_status_t +init_median_filter(filter_t *filter, size_t width, size_t height) { + if (!filter) { + return FILTER_STATUS_NULL_POINTER; + } + + if (!filter_size_is_odd(width) || !filter_size_is_odd(height)) { + return FILTER_STATUS_UNSUPPORTED_SIZE; + } + + *filter = make_rank_filter(FILTER_KIND_MEDIAN, + FILTER_CATEGORY_SMOOTHING, + FILTER_DIRECTION_NONE, + FILTER_BORDER_WRAP, + width, + height, + filter_median_rank(width, height)); + + return FILTER_STATUS_OK; +} diff --git a/src/filters/median_filter/median_filter.h b/src/filters/median_filter/median_filter.h new file mode 100644 index 0000000..11e313e --- /dev/null +++ b/src/filters/median_filter/median_filter.h @@ -0,0 +1,7 @@ +#pragma once + +#include + +filter_status_t init_median_filter(filter_t *filter, + size_t width, + size_t height); diff --git a/src/filters/motion_blur_filter/motion_blur_filter.c b/src/filters/motion_blur_filter/motion_blur_filter.c new file mode 100644 index 0000000..2f8017a --- /dev/null +++ b/src/filters/motion_blur_filter/motion_blur_filter.c @@ -0,0 +1,44 @@ +#include "motion_blur_filter.h" + +// clang-format off + +static const double blur_kernel_9x9[] = { + 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, +}; + +static const double blur_factor_9x9 = 1.0 / 9.0; +static const double blur_bias = 0.0; +// clang-format on + +filter_status_t +init_motion_blur_filter(filter_t *filter, size_t width, size_t height) { + if (!filter) { + return FILTER_STATUS_NULL_POINTER; + } + if (width != height) { + return FILTER_STATUS_UNSUPPORTED_SIZE; + } + switch (width) { + case 9: + *filter = make_convolution_filter(FILTER_KIND_MOTION_BLUR, + FILTER_CATEGORY_SMOOTHING, + FILTER_DIRECTION_DIAGONAL_45, + FILTER_BORDER_WRAP, + blur_kernel_9x9, + blur_factor_9x9, + blur_bias, + width, + height); + return FILTER_STATUS_OK; + default: + return FILTER_STATUS_UNSUPPORTED_SIZE; + } +} diff --git a/src/filters/motion_blur_filter/motion_blur_filter.h b/src/filters/motion_blur_filter/motion_blur_filter.h new file mode 100644 index 0000000..62a3426 --- /dev/null +++ b/src/filters/motion_blur_filter/motion_blur_filter.h @@ -0,0 +1,7 @@ +#pragma once + +#include + +filter_status_t init_motion_blur_filter(filter_t *filter, + size_t width, + size_t height); diff --git a/src/filters/sharpen_filter/sharpen_filter.c b/src/filters/sharpen_filter/sharpen_filter.c new file mode 100644 index 0000000..8acf2c9 --- /dev/null +++ b/src/filters/sharpen_filter/sharpen_filter.c @@ -0,0 +1,61 @@ +#include "sharpen_filter.h" + +// clang-format off +static const double sharpen_kernel_3x3[] = { + -1, -1, -1, + -1, 9, -1, + -1, -1, -1, +}; + +static const double sharpen_factor_3x3 = 1.0; +static const double sharpen_bias_3x3 = 0.0; + +static const double sharpen_kernel_5x5[] = { + -1, -1, -1, -1, -1, + -1, 2, 2, 2, -1, + -1, 2, 8, 2, -1, + -1, 2, 2, 2, -1, + -1, -1, -1, -1, -1, +}; + +static const double sharpen_factor_5x5 = 1.0 / 8.0; +static const double sharpen_bias_5x5 = 0.0; +// clang-format on + +filter_status_t +init_sharpen_filter(filter_t *filter, size_t width, size_t height) { + if (!filter) { + return FILTER_STATUS_NULL_POINTER; + } + + if (width != height) { + return FILTER_STATUS_UNSUPPORTED_SIZE; + } + + switch (width) { + case 3: + *filter = make_convolution_filter(FILTER_KIND_SHARPEN, + FILTER_CATEGORY_EDGE_ENHANCEMENT, + FILTER_DIRECTION_NONE, + FILTER_BORDER_WRAP, + sharpen_kernel_3x3, + sharpen_factor_3x3, + sharpen_bias_3x3, + width, + height); + return FILTER_STATUS_OK; + case 5: + *filter = make_convolution_filter(FILTER_KIND_SHARPEN, + FILTER_CATEGORY_EDGE_ENHANCEMENT, + FILTER_DIRECTION_NONE, + FILTER_BORDER_WRAP, + sharpen_kernel_5x5, + sharpen_factor_5x5, + sharpen_bias_5x5, + width, + height); + return FILTER_STATUS_OK; + default: + return FILTER_STATUS_UNSUPPORTED_SIZE; + } +} diff --git a/src/filters/sharpen_filter/sharpen_filter.h b/src/filters/sharpen_filter/sharpen_filter.h new file mode 100644 index 0000000..61f40c2 --- /dev/null +++ b/src/filters/sharpen_filter/sharpen_filter.h @@ -0,0 +1,7 @@ +#pragma once + +#include + +filter_status_t init_sharpen_filter(filter_t *filter, + size_t width, + size_t height); diff --git a/src/gpu_convolution/gpu_convolution.c b/src/gpu_convolution/gpu_convolution.c new file mode 100644 index 0000000..c47e736 --- /dev/null +++ b/src/gpu_convolution/gpu_convolution.c @@ -0,0 +1,145 @@ +#include "gpu_convolution.h" +#include +#include +#include +#include + +static const char *kernel_source = + "__kernel void convolve(\n" + " __global const uchar* src,\n" + " __global uchar* dst,\n" + " int width,\n" + " int height,\n" + " int stride,\n" + " int channels,\n" + " __constant float* kernel_data,\n" + " int kw, int kh,\n" + " float factor, float bias,\n" + " int border_mode)\n" + "{\n" + " int x = get_global_id(0);\n" + " int y = get_global_id(1);\n" + "\n" + " if (x >= width || y >= height) return;\n" + "\n" + " int hkw = kw / 2;\n" + " int hkh = kh / 2;\n" + "\n" + " for (int c = 0; c < channels; c++) {\n" + " if (channels == 4 && c == 3) {\n" + " dst[y * stride + x * channels + c] = src[y * stride + x * channels + c];\n" + " continue;\n" + " }\n" + "\n" + " float sum = 0.0f;\n" + " for (int ky = 0; ky < kh; ky++) {\n" + " for (int kx = 0; kx < kw; kx++) {\n" + " int ix = x + kx - hkw;\n" + " int iy = y + ky - hkh;\n" + "\n" + " if (ix < 0 || ix >= width || iy < 0 || iy >= height) {\n" + " if (border_mode == 0) {\n" + " ix = (ix % width + width) % width;\n" + " iy = (iy % height + height) % height;\n" + " } else if (border_mode == 1) {\n" + " ix = (ix < 0) ? 0 : (ix >= width ? width - 1 : ix);\n" + " iy = (iy < 0) ? 0 : (iy >= height ? height - 1 : iy);\n" + " } else if (border_mode == 2) {\n" + " if (ix < 0) ix = -ix;\n" + " if (ix >= width) ix = 2 * width - 2 - ix;\n" + " if (iy < 0) iy = -iy;\n" + " if (iy >= height) iy = 2 * height - 2 - iy;\n" + " }\n" + " }\n" + " sum += (float)src[iy * stride + ix * channels + c] * kernel_data[ky * kw + kx];\n" + " }\n" + " }\n" + " dst[y * stride + x * channels + c] = (uchar)clamp(factor * sum + bias, 0.0f, 255.0f);\n" + " }\n" + "}\n"; + +static cl_context context = NULL; +static cl_command_queue queue = NULL; +static cl_program program = NULL; +static cl_kernel kernel = NULL; +static cl_device_id device = NULL; + +static int opencl_init(void) { + if (context) return 0; + + cl_platform_id platform; + cl_int err; + + if (clGetPlatformIDs(1, &platform, NULL) != CL_SUCCESS) return -1; + + if (clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 1, &device, NULL) != CL_SUCCESS) { + if (clGetDeviceIDs(platform, CL_DEVICE_TYPE_CPU, 1, &device, NULL) != CL_SUCCESS) { + return -1; + } + } + + context = clCreateContext(NULL, 1, &device, NULL, NULL, &err); + if (err != CL_SUCCESS) return -1; + + queue = clCreateCommandQueueWithProperties(context, device, NULL, &err); + if (err != CL_SUCCESS) return -1; + + program = clCreateProgramWithSource(context, 1, &kernel_source, NULL, &err); + if (clBuildProgram(program, 1, &device, NULL, NULL, NULL) != CL_SUCCESS) { + return -1; + } + + kernel = clCreateKernel(program, "convolve", &err); + return (err == CL_SUCCESS) ? 0 : -1; +} + +int gpu_convolution(const filter_t *filter, image_view_t *view) { + if (opencl_init() != 0) return -1; + if (!filter || !view || !view->data || !filter->kernel) return -1; + + cl_int err; + size_t size = view->height * view->stride; + + cl_mem d_src = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, size, view->data, &err); + cl_mem d_dst = clCreateBuffer(context, CL_MEM_WRITE_ONLY, size, NULL, &err); + + size_t k_count = filter->width * filter->height; + float *k_data = malloc(k_count * sizeof(float)); + for (size_t i = 0; i < k_count; i++) k_data[i] = (float)filter->kernel[i]; + + cl_mem d_kern = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, k_count * sizeof(float), k_data, &err); + + int w = (int)view->width; + int h = (int)view->height; + int s = (int)view->stride; + int ch = (int)view->channels; + int kw = (int)filter->width; + int kh = (int)filter->height; + float f = (float)filter->factor; + float b = (float)filter->bias; + int bm = (int)filter->border_mode; + + clSetKernelArg(kernel, 0, sizeof(cl_mem), &d_src); + clSetKernelArg(kernel, 1, sizeof(cl_mem), &d_dst); + clSetKernelArg(kernel, 2, sizeof(int), &w); + clSetKernelArg(kernel, 3, sizeof(int), &h); + clSetKernelArg(kernel, 4, sizeof(int), &s); + clSetKernelArg(kernel, 5, sizeof(int), &ch); + clSetKernelArg(kernel, 6, sizeof(cl_mem), &d_kern); + clSetKernelArg(kernel, 7, sizeof(int), &kw); + clSetKernelArg(kernel, 8, sizeof(int), &kh); + clSetKernelArg(kernel, 9, sizeof(float), &f); + clSetKernelArg(kernel, 10, sizeof(float), &b); + clSetKernelArg(kernel, 11, sizeof(int), &bm); + + size_t global[2] = {view->width, view->height}; + err = clEnqueueNDRangeKernel(queue, kernel, 2, NULL, global, NULL, 0, NULL, NULL); + err |= clEnqueueReadBuffer(queue, d_dst, CL_TRUE, 0, size, view->data, 0, NULL, NULL); + + free(k_data); + clReleaseMemObject(d_src); + clReleaseMemObject(d_dst); + clReleaseMemObject(d_kern); + + return (err == CL_SUCCESS) ? 0 : -1; +} diff --git a/src/gpu_convolution/gpu_convolution.cl b/src/gpu_convolution/gpu_convolution.cl new file mode 100644 index 0000000..c63d046 --- /dev/null +++ b/src/gpu_convolution/gpu_convolution.cl @@ -0,0 +1,80 @@ +static int resolve_index(int value, int limit, int border_mode) { + if (limit <= 1) { + return 0; + } + + if (border_mode == 1) { + return value < 0 ? 0 : (value >= limit ? limit - 1 : value); + } + + if (border_mode == 2) { + const int period = 2 * (limit - 1); + int reflected = value % period; + + if (reflected < 0) { + reflected += period; + } + + return reflected >= limit ? period - reflected : reflected; + } + + int wrapped = value % limit; + return wrapped < 0 ? wrapped + limit : wrapped; +} + +static uchar rounded_u8(float value) { + return (uchar)clamp(floor(value + 0.5f), 0.0f, 255.0f); +} + +__kernel void convolve_rows(__global const uchar *source, + __global uchar *destination, + int width, + int height, + int stride, + int channels, + __constant float *kernel_data, + int kernel_width, + int kernel_height, + float factor, + float bias, + int border_mode, + int y_begin, + int row_count) { + const int x = get_global_id(0); + const int row = get_global_id(1); + + if (x >= width || row >= row_count) { + return; + } + + const int y = y_begin + row; + const int half_kernel_width = kernel_width / 2; + const int half_kernel_height = kernel_height / 2; + const int dst_index = y * stride + x * channels; + + for (int channel = 0; channel < channels; ++channel) { + if (channels == 4 && channel == 3) { + destination[dst_index + channel] = source[dst_index + channel]; + continue; + } + + float sum = 0.0f; + + for (int kernel_y = 0; kernel_y < kernel_height; ++kernel_y) { + const int source_y = + resolve_index(y + kernel_y - half_kernel_height, height, border_mode); + + for (int kernel_x = 0; kernel_x < kernel_width; ++kernel_x) { + const int source_x = + resolve_index(x + kernel_x - half_kernel_width, width, border_mode); + const int src_index = source_y * stride + source_x * channels + channel; + const float kernel_value = + kernel_data[kernel_y * kernel_width + kernel_x]; + + sum += (float)source[src_index] * kernel_value; + } + } + + destination[dst_index + channel] = rounded_u8(factor * sum + bias); + } +} diff --git a/src/gpu_convolution/gpu_convolution.h b/src/gpu_convolution/gpu_convolution.h new file mode 100644 index 0000000..0ca446a --- /dev/null +++ b/src/gpu_convolution/gpu_convolution.h @@ -0,0 +1,6 @@ +#pragma once + +#include +#include + +int gpu_convolution(const filter_t *filter, image_view_t *image_view); diff --git a/src/image_helpers/image_helpers.h b/src/image_helpers/image_helpers.h new file mode 100644 index 0000000..5b6e3aa --- /dev/null +++ b/src/image_helpers/image_helpers.h @@ -0,0 +1,11 @@ +#pragma once + +#include + +typedef struct image_view { + unsigned char *data; + size_t height; + size_t width; + size_t stride; + size_t channels; +} image_view_t; diff --git a/src/parallel_convolution/parallel_convolution.c b/src/parallel_convolution/parallel_convolution.c new file mode 100644 index 0000000..e90840b --- /dev/null +++ b/src/parallel_convolution/parallel_convolution.c @@ -0,0 +1,109 @@ +#include "parallel_convolution.h" + +#include +#include + +#define TILE_HEIGHT 32U +#define TILE_WIDTH 128U + +static size_t min_size(size_t lhs, size_t rhs) { + return lhs < rhs ? lhs : rhs; +} + +static int rows_executor(const convolution_context_t *context) { + int failed = 0; + +#pragma omp parallel reduction(| : failed) + { + const size_t thread_index = (size_t)omp_get_thread_num(); + const size_t thread_count = (size_t)omp_get_num_threads(); + + const size_t first_row = thread_index * context->height / thread_count; + const size_t last_row = + (thread_index + 1U) * context->height / thread_count; + + if (convolution_apply_rows(context, first_row, last_row) != 0) { + failed = 1; + } + } + + return failed ? -1 : 0; +} + +static int cols_executor(const convolution_context_t *context) { + int failed = 0; + +#pragma omp parallel reduction(| : failed) + { + const size_t thread_index = (size_t)omp_get_thread_num(); + const size_t thread_count = (size_t)omp_get_num_threads(); + + const size_t first_col = thread_index * context->width / thread_count; + const size_t last_col = (thread_index + 1U) * context->width / thread_count; + + if (convolution_apply_cols(context, first_col, last_col) != 0) { + failed = 1; + } + } + + return failed ? -1 : 0; +} + +static int pixels_executor(const convolution_context_t *context) { + int failed = 0; + const size_t pixel_count = context->height * context->width; + +#pragma omp parallel for schedule(static) reduction(| : failed) + for (size_t pixel_index = 0; pixel_index < pixel_count; ++pixel_index) { + const size_t y = pixel_index / context->width; + const size_t x = pixel_index % context->width; + + if (convolution_apply_pixel(context, y, x) != 0) { + failed = 1; + } + } + + return failed ? -1 : 0; +} + +static int tiles_executor(const convolution_context_t *context) { + int failed = 0; + +#pragma omp parallel for collapse(2) schedule(static) reduction(| : failed) + for (size_t first_row = 0; first_row < context->height; + first_row += TILE_HEIGHT) { + for (size_t first_col = 0; first_col < context->width; + first_col += TILE_WIDTH) { + const size_t last_row = + min_size(first_row + TILE_HEIGHT, context->height); + const size_t last_col = min_size(first_col + TILE_WIDTH, context->width); + + if (convolution_apply_rect( + context, first_row, last_row, first_col, last_col) != 0) { + failed = 1; + } + } + } + + return failed ? -1 : 0; +} + +int parallel_convolution_rows(const filter_t *filter, + image_view_t *image_view) { + return convolution_run(filter, image_view, rows_executor); +} + +int parallel_convolution_cols(const filter_t *filter, + image_view_t *image_view) { + return convolution_run(filter, image_view, cols_executor); +} + +int parallel_convolution_pixels(const filter_t *filter, + image_view_t *image_view) { + return convolution_run(filter, image_view, pixels_executor); +} + +int parallel_convolution_rectangle(const filter_t *filter, + image_view_t *image_view) { + return convolution_run(filter, image_view, tiles_executor); +} diff --git a/src/parallel_convolution/parallel_convolution.h b/src/parallel_convolution/parallel_convolution.h new file mode 100644 index 0000000..68c994b --- /dev/null +++ b/src/parallel_convolution/parallel_convolution.h @@ -0,0 +1,15 @@ +#pragma once + +#include +#include +#include + +int parallel_convolution_rows(const filter_t *filter, image_view_t *image_view); + +int parallel_convolution_cols(const filter_t *filter, image_view_t *image_view); + +int parallel_convolution_pixels(const filter_t *filter, + image_view_t *image_view); + +int parallel_convolution_rectangle(const filter_t *filter, + image_view_t *image_view); diff --git a/src/pipeline/image_pipeline.h b/src/pipeline/image_pipeline.h new file mode 100644 index 0000000..c85fc91 --- /dev/null +++ b/src/pipeline/image_pipeline.h @@ -0,0 +1,19 @@ +#pragma once + +#include +#include + +#define IMAGE_PIPELINE_MAX_FILTERS 2U + +typedef int (*image_convolution_runner_t)(const filter_t *filter, + image_view_t *image_view); + +typedef struct image_pipeline_request { + const char *input_path; + const char *output_path; + + filter_request_t filters[IMAGE_PIPELINE_MAX_FILTERS]; + size_t filter_count; + + image_convolution_runner_t run_convolution; +} image_pipeline_request_t; \ No newline at end of file diff --git a/src/pipeline/image_pipeline_runner.c b/src/pipeline/image_pipeline_runner.c new file mode 100644 index 0000000..09cf2e3 --- /dev/null +++ b/src/pipeline/image_pipeline_runner.c @@ -0,0 +1,257 @@ +#include "image_pipeline_runner.h" + +#include +#include +#include +#include + +#include +#include + +#include + +#define PIPELINE_WORKER_COUNT 4U +#define PIPELINE_MAX_ACTIVE_READERS 1U +#define PIPELINE_MAX_ACTIVE_COMPUTERS 2U +#define PIPELINE_MAX_ACTIVE_WRITERS 1U + +typedef enum image_job_status { + IMAGE_JOB_OK = 0, + IMAGE_JOB_READ_FAILED, + IMAGE_JOB_COMPUTE_FAILED, + IMAGE_JOB_WRITE_FAILED, + IMAGE_JOB_ENQUEUE_FAILED, +} image_job_status_t; + +typedef struct image_pipeline { + thread_pool_t pool; + atomic_bool failed; +} image_pipeline_t; + +typedef struct image_job { + image_pipeline_t *pipeline; + image_pipeline_request_t request; + + IplImage *image; + image_view_t image_view; + + image_job_status_t status; +} image_job_t; + +static void read_image_task(void *args); +static void compute_image_task(void *args); +static void write_image_task(void *args); + +static void pipeline_mark_failed(image_pipeline_t *pipeline) { + if (pipeline != NULL) { + atomic_store(&pipeline->failed, true); + } +} + +static void image_job_destroy(image_job_t *job) { + if (job == NULL) { + return; + } + + if (job->image != NULL) { + cvReleaseImage(&job->image); + } + + free(job); +} + +static bool pipeline_request_is_valid(const image_pipeline_request_t *request) { + return request != NULL && request->input_path != NULL && + request->output_path != NULL && request->filter_count != 0U && + request->filter_count <= IMAGE_PIPELINE_MAX_FILTERS && + request->run_convolution != NULL; +} + +static image_job_t *image_job_create(image_pipeline_t *pipeline, + const image_pipeline_request_t *request) { + if (pipeline == NULL || !pipeline_request_is_valid(request)) { + return NULL; + } + + image_job_t *job = (image_job_t *)calloc(1U, sizeof(*job)); + if (job == NULL) { + return NULL; + } + + job->pipeline = pipeline; + job->request = *request; + job->status = IMAGE_JOB_OK; + return job; +} + +static bool +enqueue_job_task(image_job_t *job, task_type_t task_type, task_fn_t task_fn) { + if (job == NULL || job->pipeline == NULL || task_fn == NULL) { + return false; + } + + task_t task = { + .fn = task_fn, + .fn_type = task_type, + .args = job, + }; + + return thread_pool_enqueue(&job->pipeline->pool, &task); +} + +static void cleanup_after_enqueue_failure(image_job_t *job, + const char *stage_name) { + if (job == NULL) { + return; + } + + if (job->status == IMAGE_JOB_OK) { + job->status = IMAGE_JOB_ENQUEUE_FAILED; + } + pipeline_mark_failed(job->pipeline); + + if (stage_name != NULL) { + fprintf(stderr, + "failed to enqueue %s task: %s\n", + stage_name, + job->request.input_path != NULL ? job->request.input_path : ""); + } + + image_job_destroy(job); +} + +static void enqueue_compute_or_cleanup(image_job_t *job) { + if (!enqueue_job_task(job, COMPUTE_TASK, compute_image_task)) { + cleanup_after_enqueue_failure(job, "compute"); + } +} + +static void enqueue_writer_or_cleanup(image_job_t *job) { + if (!enqueue_job_task(job, WRITER_TASK, write_image_task)) { + cleanup_after_enqueue_failure(job, "writer"); + } +} + +static int apply_filters(const image_pipeline_request_t *request, + image_view_t *image_view) { + if (request == NULL || image_view == NULL || + request->run_convolution == NULL) { + return -1; + } + + for (size_t i = 0; i < request->filter_count; ++i) { + filter_t filter; + + if (filter_init_builtin(&filter, &request->filters[i]) != + FILTER_STATUS_OK) { + return -1; + } + + if (!filter_is_convolution(&filter) || + request->run_convolution(&filter, image_view) != 0) { + return -1; + } + } + + return 0; +} + +static void read_image_task(void *args) { + image_job_t *job = args; + if (job == NULL) { + return; + } + + job->image = cvLoadImage(job->request.input_path, CV_LOAD_IMAGE_UNCHANGED); + if (job->image == NULL) { + job->status = IMAGE_JOB_READ_FAILED; + pipeline_mark_failed(job->pipeline); + fprintf(stderr, "failed to load image: %s\n", job->request.input_path); + enqueue_writer_or_cleanup(job); + return; + } + + job->image_view = (image_view_t){ + .data = (unsigned char *)job->image->imageData, + .height = (size_t)job->image->height, + .width = (size_t)job->image->width, + .stride = (size_t)job->image->widthStep, + .channels = (size_t)job->image->nChannels, + }; + + enqueue_compute_or_cleanup(job); +} + +static void compute_image_task(void *args) { + image_job_t *job = args; + if (job == NULL) { + return; + } + + if (job->status == IMAGE_JOB_OK && + apply_filters(&job->request, &job->image_view) != 0) { + job->status = IMAGE_JOB_COMPUTE_FAILED; + pipeline_mark_failed(job->pipeline); + fprintf(stderr, "failed to apply filters: %s\n", job->request.input_path); + } + + enqueue_writer_or_cleanup(job); +} + +static void write_image_task(void *args) { + image_job_t *job = args; + if (job == NULL) { + return; + } + + if (job->status == IMAGE_JOB_OK) { + if (!cvSaveImage(job->request.output_path, job->image, NULL)) { + job->status = IMAGE_JOB_WRITE_FAILED; + pipeline_mark_failed(job->pipeline); + fprintf(stderr, "failed to save image: %s\n", job->request.output_path); + } + } + + image_job_destroy(job); +} + +int image_pipeline_run(const image_pipeline_request_t *requests, + size_t request_count) { + if (requests == NULL || request_count == 0U) { + return -1; + } + + image_pipeline_t pipeline; + atomic_init(&pipeline.failed, false); + + const thread_pool_config_t config = { + .worker_count = PIPELINE_WORKER_COUNT, + .reader_queue_capacity = request_count, + .writer_queue_capacity = request_count, + .computer_queue_capacity = request_count, + .max_active_readers = PIPELINE_MAX_ACTIVE_READERS, + .max_active_writers = PIPELINE_MAX_ACTIVE_WRITERS, + .max_active_computers = PIPELINE_MAX_ACTIVE_COMPUTERS, + }; + + if (!thread_pool_init(&pipeline.pool, &config)) { + return -1; + } + + for (size_t i = 0; i < request_count; ++i) { + image_job_t *job = image_job_create(&pipeline, &requests[i]); + if (job == NULL) { + pipeline_mark_failed(&pipeline); + continue; + } + + if (!enqueue_job_task(job, READER_TASK, read_image_task)) { + cleanup_after_enqueue_failure(job, "reader"); + } + } + + thread_pool_wait(&pipeline.pool); + thread_pool_destroy(&pipeline.pool); + + return !atomic_load(&pipeline.failed) ? 0 : -1; +} diff --git a/src/pipeline/image_pipeline_runner.h b/src/pipeline/image_pipeline_runner.h new file mode 100644 index 0000000..3e727db --- /dev/null +++ b/src/pipeline/image_pipeline_runner.h @@ -0,0 +1,8 @@ +#pragma once + +#include + +#include "image_pipeline.h" + +int image_pipeline_run(const image_pipeline_request_t *requests, + size_t request_count); \ No newline at end of file diff --git a/src/runtime/task_queue.c b/src/runtime/task_queue.c new file mode 100644 index 0000000..847b751 --- /dev/null +++ b/src/runtime/task_queue.c @@ -0,0 +1,56 @@ +#include "task_queue.h" +#include + +bool task_queue_init(task_queue_t *queue, size_t capacity) { + if (capacity == 0 || !queue) { + return false; + } + queue->ring_buffer = (task_t *)malloc(sizeof(task_t) * capacity); + if (!queue->ring_buffer) { + return false; + } + queue->capacity = capacity; + queue->count = 0; + queue->head = 0; + queue->tail = 0; + return true; +} + +void task_queue_destroy(task_queue_t *queue) { + if (!queue) { + return; + } + free(queue->ring_buffer); + queue->ring_buffer = NULL; + queue->capacity = 0; + queue->count = 0; + queue->head = 0; + queue->tail = 0; +} + +bool task_queue_try_push(task_queue_t *queue, const task_t *task) { + if (!queue || !queue->ring_buffer || !task) { + return false; + } + + if (queue->count == queue->capacity) { + return false; + } + queue->ring_buffer[queue->head] = *task; + queue->head = (queue->head + 1) % queue->capacity; + ++queue->count; + return true; +} + +bool task_queue_try_pop(task_queue_t *queue, task_t *out_task) { + if (!queue || !queue->ring_buffer || !out_task) { + return false; + } + if (queue->count == 0) { + return false; + } + *out_task = queue->ring_buffer[queue->tail]; + queue->tail = (queue->tail + 1) % queue->capacity; + --queue->count; + return true; +} diff --git a/src/runtime/task_queue.h b/src/runtime/task_queue.h new file mode 100644 index 0000000..73a5951 --- /dev/null +++ b/src/runtime/task_queue.h @@ -0,0 +1,38 @@ +#pragma once + +#include +#include + +typedef enum task_type { + READER_TASK = 1, + COMPUTE_TASK, + WRITER_TASK, +} task_type_t; + +typedef void (*task_fn_t)(void *args); + +typedef struct task { + task_fn_t fn; + task_type_t fn_type; + void *args; +} task_t; + +typedef struct _task_queue { + + task_t *ring_buffer; + size_t capacity; + + size_t head; + size_t tail; + + size_t count; + +} task_queue_t; + +bool task_queue_init(task_queue_t *queue, size_t capacity); + +void task_queue_destroy(task_queue_t *queue); + +bool task_queue_try_pop(task_queue_t *queue, task_t *out_task); + +bool task_queue_try_push(task_queue_t *queue, const task_t *task); diff --git a/src/runtime/thread_pool.c b/src/runtime/thread_pool.c new file mode 100644 index 0000000..7064585 --- /dev/null +++ b/src/runtime/thread_pool.c @@ -0,0 +1,289 @@ +#include "thread_pool.h" + +#include + +static bool has_runnable_tasks(const thread_pool_t *pool) { + return (pool->writers_queue.count != 0U && + pool->active_writers < pool->max_active_writers) || + (pool->computers_queue.count != 0U && + pool->active_computers < pool->max_active_computers) || + (pool->readers_queue.count != 0U && + pool->active_readers < pool->max_active_readers); +} + +static bool has_queued_tasks(const thread_pool_t *pool) { + return pool->readers_queue.count != 0U || pool->writers_queue.count != 0U || + pool->computers_queue.count != 0U; +} + +static void destroy_sync_objects(thread_pool_t *pool) { + pthread_cond_destroy(&pool->all_done); + pthread_cond_destroy(&pool->has_space); + pthread_cond_destroy(&pool->has_work); + pthread_mutex_destroy(&pool->pool_mutex); +} + +static void *worker_main(void *args); + +bool thread_pool_init(thread_pool_t *pool, const thread_pool_config_t *config) { + if (pool == NULL || config == NULL || config->worker_count == 0U || + config->reader_queue_capacity == 0U || + config->writer_queue_capacity == 0U || + config->computer_queue_capacity == 0U || + config->max_active_readers == 0U || config->max_active_writers == 0U || + config->max_active_computers == 0U) { + return false; + } + + pool->workers = NULL; + pool->worker_count = 0U; + pool->active_tasks = 0U; + pool->active_readers = 0U; + pool->active_writers = 0U; + pool->active_computers = 0U; + pool->max_active_readers = config->max_active_readers; + pool->max_active_writers = config->max_active_writers; + pool->max_active_computers = config->max_active_computers; + pool->stopping = false; + + if (!task_queue_init(&pool->readers_queue, config->reader_queue_capacity)) { + return false; + } + if (!task_queue_init(&pool->writers_queue, config->writer_queue_capacity)) { + task_queue_destroy(&pool->readers_queue); + return false; + } + if (!task_queue_init(&pool->computers_queue, + config->computer_queue_capacity)) { + task_queue_destroy(&pool->writers_queue); + task_queue_destroy(&pool->readers_queue); + return false; + } + if (pthread_mutex_init(&pool->pool_mutex, NULL) != 0) { + task_queue_destroy(&pool->computers_queue); + task_queue_destroy(&pool->writers_queue); + task_queue_destroy(&pool->readers_queue); + return false; + } + if (pthread_cond_init(&pool->has_work, NULL) != 0) { + pthread_mutex_destroy(&pool->pool_mutex); + task_queue_destroy(&pool->computers_queue); + task_queue_destroy(&pool->writers_queue); + task_queue_destroy(&pool->readers_queue); + return false; + } + if (pthread_cond_init(&pool->has_space, NULL) != 0) { + pthread_cond_destroy(&pool->has_work); + pthread_mutex_destroy(&pool->pool_mutex); + task_queue_destroy(&pool->computers_queue); + task_queue_destroy(&pool->writers_queue); + task_queue_destroy(&pool->readers_queue); + return false; + } + if (pthread_cond_init(&pool->all_done, NULL) != 0) { + pthread_cond_destroy(&pool->has_space); + pthread_cond_destroy(&pool->has_work); + pthread_mutex_destroy(&pool->pool_mutex); + task_queue_destroy(&pool->computers_queue); + task_queue_destroy(&pool->writers_queue); + task_queue_destroy(&pool->readers_queue); + return false; + } + + pool->workers = malloc(sizeof(*pool->workers) * config->worker_count); + if (pool->workers == NULL) { + destroy_sync_objects(pool); + task_queue_destroy(&pool->computers_queue); + task_queue_destroy(&pool->writers_queue); + task_queue_destroy(&pool->readers_queue); + return false; + } + + for (size_t i = 0; i < config->worker_count; ++i) { + if (pthread_create(&pool->workers[i], NULL, worker_main, pool) != 0) { + thread_pool_destroy(pool); + return false; + } + ++pool->worker_count; + } + + return true; +} + +bool thread_pool_queue_for_task(const task_t *task, + task_queue_t **q, + thread_pool_t *pool) { + if (task == NULL || q == NULL || pool == NULL || task->fn == NULL) { + return false; + } + if (task->fn_type == WRITER_TASK) { + *q = &pool->writers_queue; + return true; + } + if (task->fn_type == COMPUTE_TASK) { + *q = &pool->computers_queue; + return true; + } + if (task->fn_type == READER_TASK) { + *q = &pool->readers_queue; + return true; + } + return false; +} + +bool thread_pool_has_pending_tasks(thread_pool_t *pool) { + return pool != NULL && (has_queued_tasks(pool) || pool->active_tasks != 0U); +} + +bool thread_pool_enqueue(thread_pool_t *pool, const task_t *task) { + task_queue_t *q = NULL; + if (!thread_pool_queue_for_task(task, &q, pool)) { + return false; + } + + pthread_mutex_lock(&pool->pool_mutex); + while (q->count == q->capacity && !pool->stopping) { + pthread_cond_wait(&pool->has_space, &pool->pool_mutex); + } + if (pool->stopping) { + pthread_mutex_unlock(&pool->pool_mutex); + return false; + } + + const bool pushed = task_queue_try_push(q, task); + if (pushed) { + pthread_cond_signal(&pool->has_work); + } + pthread_mutex_unlock(&pool->pool_mutex); + return pushed; +} + +bool thread_pool_try_enqueue(thread_pool_t *pool, const task_t *task) { + task_queue_t *q = NULL; + if (!thread_pool_queue_for_task(task, &q, pool)) { + return false; + } + + pthread_mutex_lock(&pool->pool_mutex); + if (pool->stopping || q->count == q->capacity) { + pthread_mutex_unlock(&pool->pool_mutex); + return false; + } + + const bool pushed = task_queue_try_push(q, task); + if (pushed) { + pthread_cond_signal(&pool->has_work); + } + pthread_mutex_unlock(&pool->pool_mutex); + return pushed; +} + +bool pool_thread_pop_task(thread_pool_t *pool, task_t *out_task) { + if (pool == NULL || out_task == NULL) { + return false; + } + if ((pool->active_writers < pool->max_active_writers) && + task_queue_try_pop(&pool->writers_queue, out_task)) { + return true; + } + if ((pool->active_computers < pool->max_active_computers) && + task_queue_try_pop(&pool->computers_queue, out_task)) { + return true; + } + return ((pool->active_readers < pool->max_active_readers) && + task_queue_try_pop(&pool->readers_queue, out_task)); +} + +static void *worker_main(void *args) { + thread_pool_t *pool = args; + + for (;;) { + task_t task; + + pthread_mutex_lock(&pool->pool_mutex); + while (!has_runnable_tasks(pool) && !pool->stopping) { + pthread_cond_wait(&pool->has_work, &pool->pool_mutex); + } + if (pool->stopping && !has_queued_tasks(pool)) { + pthread_mutex_unlock(&pool->pool_mutex); + return NULL; + } + + if (!pool_thread_pop_task(pool, &task)) { + pthread_mutex_unlock(&pool->pool_mutex); + continue; + } + + ++pool->active_tasks; + if (task.fn_type == READER_TASK) { + ++pool->active_readers; + } else if (task.fn_type == WRITER_TASK) { + ++pool->active_writers; + } else { + ++pool->active_computers; + } + pthread_cond_signal(&pool->has_space); + pthread_mutex_unlock(&pool->pool_mutex); + + task.fn(task.args); + + pthread_mutex_lock(&pool->pool_mutex); + --pool->active_tasks; + if (task.fn_type == READER_TASK) { + --pool->active_readers; + } else if (task.fn_type == WRITER_TASK) { + --pool->active_writers; + } else { + --pool->active_computers; + } + pthread_cond_broadcast(&pool->has_work); + if (!thread_pool_has_pending_tasks(pool)) { + pthread_cond_broadcast(&pool->all_done); + } + pthread_mutex_unlock(&pool->pool_mutex); + } +} + +void thread_pool_wait(thread_pool_t *pool) { + if (pool == NULL) { + return; + } + + pthread_mutex_lock(&pool->pool_mutex); + while (thread_pool_has_pending_tasks(pool)) { + pthread_cond_wait(&pool->all_done, &pool->pool_mutex); + } + pthread_mutex_unlock(&pool->pool_mutex); +} + +void thread_pool_shutdown(thread_pool_t *pool) { + if (pool == NULL) { + return; + } + + pthread_mutex_lock(&pool->pool_mutex); + pool->stopping = true; + pthread_cond_broadcast(&pool->has_work); + pthread_cond_broadcast(&pool->has_space); + pthread_mutex_unlock(&pool->pool_mutex); +} + +void thread_pool_destroy(thread_pool_t *pool) { + if (pool == NULL) { + return; + } + + thread_pool_shutdown(pool); + for (size_t i = 0; i < pool->worker_count; ++i) { + pthread_join(pool->workers[i], NULL); + } + + free(pool->workers); + pool->workers = NULL; + pool->worker_count = 0U; + + destroy_sync_objects(pool); + task_queue_destroy(&pool->readers_queue); + task_queue_destroy(&pool->writers_queue); + task_queue_destroy(&pool->computers_queue); +} diff --git a/src/runtime/thread_pool.h b/src/runtime/thread_pool.h new file mode 100644 index 0000000..ad44d12 --- /dev/null +++ b/src/runtime/thread_pool.h @@ -0,0 +1,65 @@ +#pragma once + +#include +#include "task_queue.h" + +typedef struct thread_pool_config { + size_t worker_count; + + size_t reader_queue_capacity; + size_t writer_queue_capacity; + size_t computer_queue_capacity; + + size_t max_active_readers; + size_t max_active_writers; + size_t max_active_computers; + +} thread_pool_config_t; +typedef struct _thread_pool { + + pthread_t *workers; + + task_queue_t readers_queue; + task_queue_t writers_queue; + task_queue_t computers_queue; + + pthread_cond_t has_work; + pthread_cond_t has_space; + pthread_cond_t all_done; + + pthread_mutex_t pool_mutex; + + size_t active_tasks; + + size_t active_readers; + size_t active_writers; + size_t active_computers; + + size_t max_active_readers; + size_t max_active_writers; + size_t max_active_computers; + + size_t worker_count; + bool stopping; + +} thread_pool_t; + +bool thread_pool_enqueue(thread_pool_t *pool, const task_t *task); + +bool thread_pool_has_pending_tasks(thread_pool_t *pool); + +bool thread_pool_try_enqueue(thread_pool_t *pool, const task_t *task); + +bool thread_pool_queue_for_task(const task_t *task, + task_queue_t **q, + thread_pool_t *pool); + +bool thread_pool_init(thread_pool_t *pool, const thread_pool_config_t *config); + +bool pool_thread_pop_task(thread_pool_t *pool, task_t *out_task); + +void thread_pool_wait(thread_pool_t *pool); + +void thread_pool_destroy(thread_pool_t *pool); + +void thread_pool_shutdown(thread_pool_t *pool); diff --git a/src/sequentially_convolution/sequentially_convolution.c b/src/sequentially_convolution/sequentially_convolution.c new file mode 100644 index 0000000..2f5ca09 --- /dev/null +++ b/src/sequentially_convolution/sequentially_convolution.c @@ -0,0 +1,12 @@ +#include "sequentially_convolution.h" + +#include + +static int sequential_executor(const convolution_context_t *context) { + return convolution_apply_rect( + context, 0U, context->height, 0U, context->width); +} + +int sequential_convolution(const filter_t *filter, image_view_t *image_view) { + return convolution_run(filter, image_view, sequential_executor); +} diff --git a/src/sequentially_convolution/sequentially_convolution.h b/src/sequentially_convolution/sequentially_convolution.h new file mode 100644 index 0000000..d4731bb --- /dev/null +++ b/src/sequentially_convolution/sequentially_convolution.h @@ -0,0 +1,7 @@ +#pragma once + +#include +#include +#include + +int sequential_convolution(const filter_t *filter, image_view_t *image_view); diff --git a/test/sequential_tests/CMakeLists.txt b/test/sequential_tests/CMakeLists.txt new file mode 100644 index 0000000..d5d04b7 --- /dev/null +++ b/test/sequential_tests/CMakeLists.txt @@ -0,0 +1,23 @@ +add_executable(sequential_tests + sequential_tests.c +) + +target_link_libraries(sequential_tests + PRIVATE + convolution_runtime + PkgConfig::CMOCKA +) + +add_test(NAME sequential_tests COMMAND sequential_tests) + +add_executable(sequential_opencv_reference_tests + sequential_opencv_reference_tests.c +) + +target_link_libraries(sequential_opencv_reference_tests + PRIVATE + convolution_runtime + PkgConfig::CMOCKA +) + +add_test(NAME sequential_opencv_reference_tests COMMAND sequential_opencv_reference_tests) diff --git a/test/sequential_tests/sequential_opencv_reference_tests.c b/test/sequential_tests/sequential_opencv_reference_tests.c new file mode 100644 index 0000000..be2b8d5 --- /dev/null +++ b/test/sequential_tests/sequential_opencv_reference_tests.c @@ -0,0 +1,419 @@ +#include +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include + +#define MAX_IMAGE_BYTES 2048U +#define TEST_NAME_SIZE 128U +#define RANDOM_PIXEL_MASK 63U +#define ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0])) + +typedef struct test_image { + unsigned char data[MAX_IMAGE_BYTES]; + image_view_t view; + size_t size; +} test_image_t; + +typedef struct kernel_sample { + const char *name; + const double *values; + size_t width; + size_t height; + double factor; + double bias; +} kernel_sample_t; + +static uint32_t random_state = 0x12345678U; + +static unsigned char random_byte(void) { + random_state = random_state * 1664525U + 1013904223U; + return (unsigned char)(random_state >> 24U); +} + +static void init_image(test_image_t *image, + size_t width, + size_t height, + size_t channels, + size_t padding) { + const size_t stride = width * channels + padding; + + image->size = height * stride; + image->view = (image_view_t){ + .data = image->data, + .height = height, + .width = width, + .stride = stride, + .channels = channels, + }; + + memset(image->data, 0, sizeof(image->data)); +} + +static unsigned char *pixel(test_image_t *image, size_t x, size_t y) { + return image->data + y * image->view.stride + x * image->view.channels; +} + +static const unsigned char * +const_pixel(const test_image_t *image, size_t x, size_t y) { + return image->data + y * image->view.stride + x * image->view.channels; +} + +static void fill_random(test_image_t *image) { + for (size_t y = 0; y < image->view.height; ++y) { + for (size_t x = 0; x < image->view.width; ++x) { + unsigned char *current_pixel = pixel(image, x, y); + + for (size_t channel = 0; channel < image->view.channels; ++channel) { + current_pixel[channel] = random_byte() & RANDOM_PIXEL_MASK; + } + } + + for (size_t i = image->view.width * image->view.channels; + i < image->view.stride; + ++i) { + image->data[y * image->view.stride + i] = random_byte(); + } + } +} + +static void copy_image(test_image_t *to, const test_image_t *from) { + memcpy(to->data, from->data, from->size); + to->size = from->size; + to->view = from->view; + to->view.data = to->data; +} + +static unsigned char clamp_to_byte(double value) { + if (value < 0.0) { + return 0U; + } + if (value > 255.0) { + return 255U; + } + return (unsigned char)(value + 0.5); +} + +static int cv_border(filter_border_mode_t border) { + switch (border) { + case FILTER_BORDER_WRAP: + return IPL_BORDER_WRAP; + case FILTER_BORDER_REFLECT: + return IPL_BORDER_REFLECT_101; + case FILTER_BORDER_CLAMP: + default: + return IPL_BORDER_REPLICATE; + } +} + +static const char *border_name(filter_border_mode_t border) { + switch (border) { + case FILTER_BORDER_WRAP: + return "wrap"; + case FILTER_BORDER_REFLECT: + return "reflect"; + case FILTER_BORDER_CLAMP: + default: + return "clamp"; + } +} + +static filter_t make_test_filter(const kernel_sample_t *kernel, + filter_border_mode_t border) { + return make_convolution_filter(FILTER_KIND_BLUR, + FILTER_CATEGORY_SMOOTHING, + FILTER_DIRECTION_NONE, + border, + kernel->values, + kernel->factor, + kernel->bias, + kernel->width, + kernel->height); +} + +static CvMat *make_cv_kernel(const kernel_sample_t *kernel) { + CvMat *cv_kernel = + cvCreateMat((int)kernel->height, (int)kernel->width, CV_64FC1); + + if (cv_kernel == NULL) { + return NULL; + } + + for (size_t y = 0; y < kernel->height; ++y) { + for (size_t x = 0; x < kernel->width; ++x) { + const double value = kernel->values[y * kernel->width + x]; + cvmSet(cv_kernel, (int)y, (int)x, value * kernel->factor); + } + } + + return cv_kernel; +} + +static CvMat *run_opencv_filter(const test_image_t *source, + const kernel_sample_t *kernel, + filter_border_mode_t border) { + const int channels = (int)source->view.channels; + const int input_type = CV_MAKETYPE(CV_8U, channels); + const int result_type = CV_MAKETYPE(CV_64F, channels); + const int radius_x = (int)(kernel->width / 2U); + const int radius_y = (int)(kernel->height / 2U); + + CvMat source_header; + CvMat *padded = NULL; + CvMat *result = NULL; + CvMat *cv_kernel = NULL; + + cvInitMatHeader(&source_header, + (int)source->view.height, + (int)source->view.width, + input_type, + (void *)source->data, + (int)source->view.stride); + + padded = cvCreateMat((int)source->view.height + 2 * radius_y, + (int)source->view.width + 2 * radius_x, + input_type); + result = cvCreateMat((int)source->view.height + 2 * radius_y, + (int)source->view.width + 2 * radius_x, + result_type); + cv_kernel = make_cv_kernel(kernel); + + if (padded == NULL || result == NULL || cv_kernel == NULL) { + cvReleaseMat(&padded); + cvReleaseMat(&result); + cvReleaseMat(&cv_kernel); + return NULL; + } + + /* cvFilter2D from OpenCV 2 C API always uses its own border mode. + To compare the same border handling as our code, pad the image first. */ + cvCopyMakeBorder(&source_header, + padded, + cvPoint(radius_x, radius_y), + cv_border(border), + cvScalarAll(0.0)); + cvFilter2D(padded, result, cv_kernel, cvPoint(radius_x, radius_y)); + + cvReleaseMat(&padded); + cvReleaseMat(&cv_kernel); + return result; +} + +static int padding_is_same(const test_image_t *before, + const test_image_t *after) { + const size_t row_pixels = after->view.width * after->view.channels; + + for (size_t y = 0; y < after->view.height; ++y) { + const unsigned char *before_padding = + before->data + y * before->view.stride + row_pixels; + const unsigned char *after_padding = + after->data + y * after->view.stride + row_pixels; + const size_t padding_size = after->view.stride - row_pixels; + + if (memcmp(before_padding, after_padding, padding_size) != 0) { + return 0; + } + } + + return 1; +} + +static int compare_with_opencv(const test_image_t *source, + const test_image_t *actual, + const kernel_sample_t *kernel, + const CvMat *opencv_result, + const char *test_name) { + const int radius_x = (int)(kernel->width / 2U); + const int radius_y = (int)(kernel->height / 2U); + + for (size_t y = 0; y < actual->view.height; ++y) { + const double *opencv_row = + (const double *)(const void *)(opencv_result->data.ptr + + ((int)y + radius_y) * opencv_result->step); + + for (size_t x = 0; x < actual->view.width; ++x) { + const unsigned char *source_pixel = const_pixel(source, x, y); + const unsigned char *actual_pixel = const_pixel(actual, x, y); + + for (size_t channel = 0; channel < actual->view.channels; ++channel) { + const double cv_value = + opencv_row[((int)x + radius_x) * actual->view.channels + channel] + + kernel->bias; + const unsigned char expected = + (actual->view.channels == 4U && channel == 3U) + ? source_pixel[channel] + : clamp_to_byte(cv_value); + + if (actual_pixel[channel] != expected) { + fail_msg("%s: pixel (%zu, %zu), channel %zu: got %u, expected %u", + test_name, + x, + y, + channel, + (unsigned)actual_pixel[channel], + (unsigned)expected); + return 0; + } + } + } + } + + if (!padding_is_same(source, actual)) { + fail_msg("%s: image row padding changed", test_name); + return 0; + } + + return 1; +} + +static void check_case(size_t width, + size_t height, + size_t channels, + const kernel_sample_t *kernel, + filter_border_mode_t border) { + const size_t padding = (width + height + channels) % 4U; + char test_name[TEST_NAME_SIZE]; + test_image_t source; + test_image_t actual; + CvMat *opencv_result = NULL; + + snprintf(test_name, + sizeof(test_name), + "%zux%zux%zu, %s, %s border", + width, + height, + channels, + kernel->name, + border_name(border)); + + init_image(&source, width, height, channels, padding); + fill_random(&source); + copy_image(&actual, &source); + + filter_t filter = make_test_filter(kernel, border); + assert_int_equal(sequential_convolution(&filter, &actual.view), 0); + + opencv_result = run_opencv_filter(&source, kernel, border); + assert_non_null(opencv_result); + + assert_true( + compare_with_opencv(&source, &actual, kernel, opencv_result, test_name)); + cvReleaseMat(&opencv_result); +} + +static void sequential_convolution_matches_opencv(void **state) { + (void)state; + + static const double identity[] = {1.0}; + static const double gaussian_3x3[] = { + 1.0, + 2.0, + 1.0, + 2.0, + 4.0, + 2.0, + 1.0, + 2.0, + 1.0, + }; + static const double sharpen_3x3[] = { + 0.0, + -1.0, + 0.0, + -1.0, + 5.0, + -1.0, + 0.0, + -1.0, + 0.0, + }; + static const double tall_3x5[] = { + 0.0, + 1.0, + 0.0, + -1.0, + 2.0, + -1.0, + 0.0, + 3.0, + 0.0, + -1.0, + 2.0, + -1.0, + 0.0, + 1.0, + 0.0, + }; + static const double wide_5x3[] = { + 0.0, + -1.0, + 0.0, + 1.0, + 0.0, + 1.0, + 2.0, + 3.0, + 2.0, + 1.0, + 0.0, + 1.0, + 0.0, + -1.0, + 0.0, + }; + + const size_t widths[] = {1U, 2U, 3U, 5U, 8U, 13U}; + const size_t heights[] = {1U, 2U, 4U, 7U}; + const size_t channels[] = {1U, 3U, 4U}; + const filter_border_mode_t borders[] = { + FILTER_BORDER_WRAP, + FILTER_BORDER_CLAMP, + FILTER_BORDER_REFLECT, + }; + const kernel_sample_t kernels[] = { + {"identity", identity, 1U, 1U, 1.0, 0.0}, + {"gaussian 3x3", gaussian_3x3, 3U, 3U, 1.0 / 16.0, 0.0}, + {"sharpen 3x3", sharpen_3x3, 3U, 3U, 1.0, 0.0}, + {"3x5", tall_3x5, 3U, 5U, 1.0, 3.0}, + {"5x3", wide_5x3, 5U, 3U, 1.0, 7.0}, + }; + + for (size_t width_index = 0; width_index < ARRAY_SIZE(widths); + ++width_index) { + for (size_t height_index = 0; height_index < ARRAY_SIZE(heights); + ++height_index) { + for (size_t channel_index = 0; channel_index < ARRAY_SIZE(channels); + ++channel_index) { + for (size_t kernel_index = 0; kernel_index < ARRAY_SIZE(kernels); + ++kernel_index) { + for (size_t border_index = 0; border_index < ARRAY_SIZE(borders); + ++border_index) { + check_case(widths[width_index], + heights[height_index], + channels[channel_index], + &kernels[kernel_index], + borders[border_index]); + } + } + } + } + } +} + +int main(void) { + const struct CMUnitTest tests[] = { + cmocka_unit_test(sequential_convolution_matches_opencv), + }; + + return cmocka_run_group_tests(tests, NULL, NULL); +} diff --git a/test/sequential_tests/sequential_tests.c b/test/sequential_tests/sequential_tests.c new file mode 100644 index 0000000..916dd72 --- /dev/null +++ b/test/sequential_tests/sequential_tests.c @@ -0,0 +1,363 @@ +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include + +#define MAX_IMAGE_BYTES 4096U +#define ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0])) + +typedef struct test_image { + unsigned char data[MAX_IMAGE_BYTES]; + image_view_t view; + size_t size; +} test_image_t; + +static uint32_t random_state = 0x12345678U; + +static unsigned char random_byte(void) { + random_state = random_state * 1664525U + 1013904223U; + return (unsigned char)(random_state >> 24U); +} + +static void init_image(test_image_t *image, + size_t width, + size_t height, + size_t channels, + size_t padding) { + const size_t stride = width * channels + padding; + + image->size = height * stride; + image->view = (image_view_t){ + .data = image->data, + .height = height, + .width = width, + .stride = stride, + .channels = channels, + }; + + memset(image->data, 0xCD, sizeof(image->data)); +} + +static void fill_random(test_image_t *image) { + for (size_t i = 0; i < image->size; ++i) { + image->data[i] = random_byte(); + } +} + +static void copy_image(test_image_t *to, const test_image_t *from) { + memcpy(to->data, from->data, from->size); +} + +static int same_image(const test_image_t *left, const test_image_t *right) { + if (left->size != right->size) { + return 0; + } + return memcmp(left->data, right->data, left->size) == 0; +} + +static filter_t make_filter(const double *kernel, + size_t width, + size_t height, + double factor, + filter_border_mode_t border_mode) { + return make_convolution_filter(FILTER_KIND_BLUR, + FILTER_CATEGORY_SMOOTHING, + FILTER_DIRECTION_NONE, + border_mode, + kernel, + factor, + 0.0, + width, + height); +} + +static void apply_filter(test_image_t *image, + const double *kernel, + size_t width, + size_t height, + double factor, + filter_border_mode_t border_mode) { + filter_t filter = make_filter(kernel, width, height, factor, border_mode); + assert_int_equal(sequential_convolution(&filter, &image->view), 0); +} + +static void make_identity_kernel(double *kernel, size_t size) { + memset(kernel, 0, size * size * sizeof(*kernel)); + kernel[(size / 2U) * size + size / 2U] = 1.0; +} + +static void make_shift_kernel(double *kernel, int dx, int dy) { + const int center = 1; + + memset(kernel, 0, 9U * sizeof(*kernel)); + kernel[(size_t)(center + dy) * 3U + (size_t)(center + dx)] = 1.0; +} + +static unsigned char *pixel(test_image_t *image, size_t x, size_t y) { + return image->data + y * image->view.stride + x * image->view.channels; +} + +static const unsigned char * +const_pixel(const test_image_t *image, size_t x, size_t y) { + return image->data + y * image->view.stride + x * image->view.channels; +} + +static void set_one_channel_image(test_image_t *image, + const unsigned char *values) { + for (size_t y = 0; y < image->view.height; ++y) { + for (size_t x = 0; x < image->view.width; ++x) { + *pixel(image, x, y) = values[y * image->view.width + x]; + } + } +} + +static int one_channel_image_has_values(const test_image_t *image, + const unsigned char *values) { + for (size_t y = 0; y < image->view.height; ++y) { + for (size_t x = 0; x < image->view.width; ++x) { + if (*const_pixel(image, x, y) != values[y * image->view.width + x]) { + return 0; + } + } + } + return 1; +} + +static void identity_filter_keeps_image(void **state) { + (void)state; + const size_t kernel_sizes[] = {1U, 3U, 5U, 7U}; + const filter_border_mode_t borders[] = { + FILTER_BORDER_WRAP, + FILTER_BORDER_CLAMP, + FILTER_BORDER_REFLECT, + }; + + for (size_t channels = 1U; channels <= 4U; ++channels) { + if (channels == 2U) { + continue; + } + + for (size_t i = 0; i < ARRAY_SIZE(kernel_sizes); + ++i) { + double kernel[49]; + test_image_t original; + test_image_t actual; + + init_image(&original, 8U, 5U, channels, 3U); + init_image(&actual, 8U, 5U, channels, 3U); + + fill_random(&original); + make_identity_kernel(kernel, kernel_sizes[i]); + + for (size_t b = 0; b < ARRAY_SIZE(borders); ++b) { + copy_image(&actual, &original); + apply_filter( + &actual, kernel, kernel_sizes[i], kernel_sizes[i], 1.0, borders[b]); + assert_true(same_image(&original, &actual)); + } + } + } + +} + +static void zero_filter_makes_rgb_black_and_keeps_alpha(void **state) { + (void)state; + double zero_kernel[9] = {0.0}; + test_image_t original; + test_image_t actual; + + init_image(&original, 7U, 4U, 4U, 2U); + init_image(&actual, 7U, 4U, 4U, 2U); + + fill_random(&original); + copy_image(&actual, &original); + + apply_filter(&actual, zero_kernel, 3U, 3U, 1.0, FILTER_BORDER_REFLECT); + + for (size_t y = 0; y < actual.view.height; ++y) { + for (size_t x = 0; x < actual.view.width; ++x) { + const unsigned char *before = const_pixel(&original, x, y); + const unsigned char *after = const_pixel(&actual, x, y); + + assert_int_equal(after[0], 0U); + assert_int_equal(after[1], 0U); + assert_int_equal(after[2], 0U); + assert_int_equal(after[3], before[3]); + } + } + +} + +static void shift_filter_respects_border_modes(void **state) { + (void)state; + double shift_right[9]; + + // clang-format off + const unsigned char source_values[] = { + 1U, 2U, 3U, + 4U, 5U, 6U, + }; + const unsigned char wrap_expected[] = { + 2U, 3U, 1U, + 5U, 6U, 4U, + }; + const unsigned char clamp_expected[] = { + 2U, 3U, 3U, + 5U, 6U, 6U, + }; + const unsigned char reflect_expected[] = { + 2U, 3U, 2U, + 5U, 6U, 5U, + }; + // clang-format on + + test_image_t image; + + init_image(&image, 3U, 2U, 1U, 1U); + + make_shift_kernel(shift_right, 1, 0); + + set_one_channel_image(&image, source_values); + apply_filter(&image, shift_right, 3U, 3U, 1.0, FILTER_BORDER_WRAP); + assert_true(one_channel_image_has_values(&image, wrap_expected)); + + set_one_channel_image(&image, source_values); + apply_filter(&image, shift_right, 3U, 3U, 1.0, FILTER_BORDER_CLAMP); + assert_true(one_channel_image_has_values(&image, clamp_expected)); + + set_one_channel_image(&image, source_values); + apply_filter(&image, shift_right, 3U, 3U, 1.0, FILTER_BORDER_REFLECT); + assert_true(one_channel_image_has_values(&image, reflect_expected)); + +} + +static void opposite_shifts_compose_to_identity_with_wrap(void **state) { + (void)state; + double shift_right[9]; + double shift_left[9]; + double shift_down[9]; + double shift_up[9]; + test_image_t original; + test_image_t actual; + + init_image(&original, 9U, 7U, 3U, 4U); + init_image(&actual, 9U, 7U, 3U, 4U); + + make_shift_kernel(shift_right, 1, 0); + make_shift_kernel(shift_left, -1, 0); + make_shift_kernel(shift_down, 0, 1); + make_shift_kernel(shift_up, 0, -1); + + fill_random(&original); + + copy_image(&actual, &original); + apply_filter(&actual, shift_right, 3U, 3U, 1.0, FILTER_BORDER_WRAP); + apply_filter(&actual, shift_left, 3U, 3U, 1.0, FILTER_BORDER_WRAP); + assert_true(same_image(&original, &actual)); + + copy_image(&actual, &original); + apply_filter(&actual, shift_down, 3U, 3U, 1.0, FILTER_BORDER_WRAP); + apply_filter(&actual, shift_up, 3U, 3U, 1.0, FILTER_BORDER_WRAP); + assert_true(same_image(&original, &actual)); + +} + +static void zero_padded_kernel_gives_same_result(void **state) { + (void)state; + + // clang-format off + const double kernel_3x3[9] = { + 0.0, 1.0, 0.0, + 1.0, 4.0, 1.0, + 0.0, 1.0, 0.0, + }; + const double same_kernel_padded_to_5x5[25] = { + 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 1.0, 0.0, 0.0, + 0.0, 1.0, 4.0, 1.0, 0.0, + 0.0, 0.0, 1.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, + }; + // clang-format on + + const filter_border_mode_t borders[] = { + FILTER_BORDER_WRAP, + FILTER_BORDER_CLAMP, + FILTER_BORDER_REFLECT, + }; + test_image_t source; + test_image_t small_kernel_result; + test_image_t padded_kernel_result; + + init_image(&source, 10U, 6U, 3U, 2U); + init_image(&small_kernel_result, 10U, 6U, 3U, 2U); + init_image(&padded_kernel_result, 10U, 6U, 3U, 2U); + + fill_random(&source); + + for (size_t i = 0; i < ARRAY_SIZE(borders); ++i) { + copy_image(&small_kernel_result, &source); + copy_image(&padded_kernel_result, &source); + + apply_filter(&small_kernel_result, kernel_3x3, 3U, 3U, 1.0, borders[i]); + apply_filter(&padded_kernel_result, + same_kernel_padded_to_5x5, + 5U, + 5U, + 1.0, + borders[i]); + assert_true(same_image(&small_kernel_result, &padded_kernel_result)); + } + +} + +static void known_wrap_mean_3x3(void **state) { + (void)state; + double mean_kernel[9]; + test_image_t image; + + init_image(&image, 3U, 3U, 1U, 0U); + + // clang-format off + const unsigned char values[] = { + 1U, 2U, 3U, + 4U, 5U, 6U, + 7U, 8U, 9U, + }; + const unsigned char expected[] = { + 5U, 5U, 5U, + 5U, 5U, 5U, + 5U, 5U, 5U, + }; + // clang-format on + + for (size_t i = 0; i < 9U; ++i) { + mean_kernel[i] = 1.0; + } + + set_one_channel_image(&image, values); + apply_filter(&image, mean_kernel, 3U, 3U, 1.0 / 9.0, FILTER_BORDER_WRAP); + assert_true(one_channel_image_has_values(&image, expected)); + +} + +int main(void) { + const struct CMUnitTest tests[] = { + cmocka_unit_test(identity_filter_keeps_image), + cmocka_unit_test(zero_filter_makes_rgb_black_and_keeps_alpha), + cmocka_unit_test(shift_filter_respects_border_modes), + cmocka_unit_test(opposite_shifts_compose_to_identity_with_wrap), + cmocka_unit_test(zero_padded_kernel_gives_same_result), + cmocka_unit_test(known_wrap_mean_3x3), + }; + + return cmocka_run_group_tests(tests, NULL, NULL); +} diff --git a/test/thread_pool_tests/CMakeLists.txt b/test/thread_pool_tests/CMakeLists.txt new file mode 100644 index 0000000..e0fd0f7 --- /dev/null +++ b/test/thread_pool_tests/CMakeLists.txt @@ -0,0 +1,11 @@ +add_executable(thread_pool_tests + thread_pool_test.c +) + +target_link_libraries(thread_pool_tests + PRIVATE + convolution_runtime + PkgConfig::CMOCKA +) + +add_test(NAME thread_pool_tests COMMAND thread_pool_tests) diff --git a/test/thread_pool_tests/thread_pool_test.c b/test/thread_pool_tests/thread_pool_test.c new file mode 100644 index 0000000..dffc1a8 --- /dev/null +++ b/test/thread_pool_tests/thread_pool_test.c @@ -0,0 +1,81 @@ +#include + +#include +#include +#include + +#include + +#define THREAD_POOL_WORKERS 2U +#define TASK_COUNT 32U + +typedef struct counter_task_args { + size_t *counter; + pthread_mutex_t *mutex; +} counter_task_args_t; + +static void increment_counter(void *args) { + counter_task_args_t *task_args = args; + + pthread_mutex_lock(task_args->mutex); + ++(*task_args->counter); + pthread_mutex_unlock(task_args->mutex); +} + +static task_t make_counter_task(counter_task_args_t *args, size_t index) { + const task_type_t task_types[] = { + READER_TASK, + COMPUTE_TASK, + WRITER_TASK, + }; + + return (task_t){ + .fn = increment_counter, + .fn_type = task_types[index % (sizeof(task_types) / sizeof(task_types[0]))], + .args = args, + }; +} + +static void thread_pool_runs_all_tasks(void **state) { + (void)state; + + thread_pool_t pool; + pthread_mutex_t counter_mutex; + counter_task_args_t args[TASK_COUNT]; + size_t counter = 0U; + + const thread_pool_config_t config = { + .worker_count = THREAD_POOL_WORKERS, + .reader_queue_capacity = TASK_COUNT, + .computer_queue_capacity = TASK_COUNT, + .writer_queue_capacity = TASK_COUNT, + .max_active_readers = 1U, + .max_active_computers = 1U, + .max_active_writers = 1U, + }; + + assert_int_equal(pthread_mutex_init(&counter_mutex, NULL), 0); + assert_true(thread_pool_init(&pool, &config)); + + for (size_t i = 0; i < TASK_COUNT; ++i) { + args[i].counter = &counter; + args[i].mutex = &counter_mutex; + + task_t task = make_counter_task(&args[i], i); + assert_true(thread_pool_enqueue(&pool, &task)); + } + + thread_pool_wait(&pool); + thread_pool_destroy(&pool); + pthread_mutex_destroy(&counter_mutex); + + assert_int_equal(counter, TASK_COUNT); +} + +int main(void) { + const struct CMUnitTest tests[] = { + cmocka_unit_test(thread_pool_runs_all_tasks), + }; + + return cmocka_run_group_tests(tests, NULL, NULL); +}