fast_resize 1.0.0

data/src/thread_pool.cpp

@@ -0,0 +1,232 @@
+/*
+ * FastResize - The Fastest Image Resizing Library On The Planet
+ * Copyright (C) 2025 Tran Huu Canh (0xTh3OKrypt) and FastResize Contributors
+ *
+ * Resize 1,000 images in 2 seconds. Up to 2.9x faster than libvips,
+ * 3.1x faster than imageflow. Uses 3-4x less RAM than alternatives.
+ *
+ * Author: Tran Huu Canh (0xTh3OKrypt)
+ * Email: tranhuucanh39@gmail.com
+ * Homepage: https://github.com/tranhuucanh/fast_resize
+ *
+ * BSD 3-Clause License
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "internal.h"
+#include <thread>
+#include <mutex>
+#include <condition_variable>
+#include <queue>
+#include <functional>
+#include <atomic>
+#include <vector>
+
+namespace fastresize {
+namespace internal {
+
+class ThreadPool {
+public:
+    explicit ThreadPool(size_t num_threads);
+    ~ThreadPool();
+
+    void enqueue(std::function<void()> task);
+
+    void wait();
+
+    size_t get_thread_count() const { return threads_.size(); }
+
+private:
+    std::vector<std::thread> threads_;
+    std::queue<std::function<void()>> tasks_;
+    std::mutex queue_mutex_;
+    std::condition_variable condition_;
+    std::condition_variable wait_condition_;
+    std::atomic<bool> stop_;
+    std::atomic<int> active_tasks_;
+    std::atomic<int> queued_tasks_;
+};
+
+ThreadPool::ThreadPool(size_t num_threads)
+    : stop_(false)
+    , active_tasks_(0)
+    , queued_tasks_(0)
+{
+    for (size_t i = 0; i < num_threads; ++i) {
+        threads_.emplace_back([this] {
+            while (true) {
+                std::function<void()> task;
+                {
+                    std::unique_lock<std::mutex> lock(queue_mutex_);
+                    condition_.wait(lock, [this] {
+                        return stop_ || !tasks_.empty();
+                    });
+
+                    if (stop_ && tasks_.empty())
+                        return;
+
+                    task = std::move(tasks_.front());
+                    tasks_.pop();
+                    --queued_tasks_;
+                }
+
+                ++active_tasks_;
+                task();
+                --active_tasks_;
+                wait_condition_.notify_all();
+            }
+        });
+    }
+}
+
+ThreadPool::~ThreadPool() {
+    {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
+        stop_ = true;
+    }
+    condition_.notify_all();
+    for (std::thread& thread : threads_) {
+        if (thread.joinable()) {
+            thread.join();
+        }
+    }
+}
+
+void ThreadPool::enqueue(std::function<void()> task) {
+    {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
+        tasks_.emplace(std::move(task));
+        ++queued_tasks_;
+    }
+    condition_.notify_one();
+}
+
+void ThreadPool::wait() {
+    std::unique_lock<std::mutex> lock(queue_mutex_);
+    wait_condition_.wait(lock, [this] {
+        return queued_tasks_ == 0 && active_tasks_ == 0;
+    });
+}
+
+class BufferPool {
+public:
+    BufferPool() = default;
+    ~BufferPool();
+
+    unsigned char* acquire(size_t size);
+    void release(unsigned char* buffer, size_t capacity);
+
+private:
+    struct Buffer {
+        unsigned char* data;
+        size_t capacity;
+    };
+
+    std::vector<Buffer> pool_;
+    std::mutex mutex_;
+};
+
+BufferPool::~BufferPool() {
+    std::lock_guard<std::mutex> lock(mutex_);
+    for (Buffer& buf : pool_) {
+        delete[] buf.data;
+    }
+    pool_.clear();
+}
+
+unsigned char* BufferPool::acquire(size_t size) {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    for (auto it = pool_.begin(); it != pool_.end(); ++it) {
+        if (it->capacity >= size) {
+            unsigned char* buffer = it->data;
+            pool_.erase(it);
+            return buffer;
+        }
+    }
+
+    return new unsigned char[size];
+}
+
+void BufferPool::release(unsigned char* buffer, size_t capacity) {
+    if (!buffer) return;
+
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    if (pool_.size() < 32) {
+        Buffer buf;
+        buf.data = buffer;
+        buf.capacity = capacity;
+        pool_.push_back(buf);
+    } else {
+        delete[] buffer;
+    }
+}
+
+ThreadPool* create_thread_pool(size_t num_threads) {
+    return new ThreadPool(num_threads);
+}
+
+void destroy_thread_pool(ThreadPool* pool) {
+    delete pool;
+}
+
+void thread_pool_enqueue(ThreadPool* pool, std::function<void()> task) {
+    if (pool) {
+        pool->enqueue(std::move(task));
+    }
+}
+
+void thread_pool_wait(ThreadPool* pool) {
+    if (pool) {
+        pool->wait();
+    }
+}
+
+BufferPool* create_buffer_pool() {
+    return new BufferPool();
+}
+
+void destroy_buffer_pool(BufferPool* pool) {
+    delete pool;
+}
+
+unsigned char* buffer_pool_acquire(BufferPool* pool, size_t size) {
+    return pool ? pool->acquire(size) : new unsigned char[size];
+}
+
+void buffer_pool_release(BufferPool* pool, unsigned char* buffer, size_t capacity) {
+    if (pool) {
+        pool->release(buffer, capacity);
+    } else {
+        delete[] buffer;
+    }
+}
+
+}
+}

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: fast_resize
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Tran Huu Canh (0xTh3OKrypt)
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-12-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Resize 1,000 images in 2 seconds. Up to 2.9x faster than libvips, 3.1x
+  faster than imageflow. Uses 3-4x less RAM than alternatives.
+email:
+- tranhuucanh39@gmail.com
+executables: []
+extensions:
+- bindings/ruby/ext/fastresize/extconf.rb
+extra_rdoc_files: []
+files:
+- CMakeLists.txt
+- LICENSE
+- README.md
+- VERSION
+- bindings/ruby/ext/fastresize/extconf.rb
+- bindings/ruby/ext/fastresize/fastresize_ext.cpp
+- bindings/ruby/lib/fastresize.rb
+- bindings/ruby/lib/fastresize/platform.rb
+- bindings/ruby/lib/fastresize/version.rb
+- bindings/ruby/prebuilt/linux-aarch64.tar.gz
+- bindings/ruby/prebuilt/linux-aarch64/bin/fast_resize
+- bindings/ruby/prebuilt/linux-aarch64/include/fastresize.h
+- bindings/ruby/prebuilt/linux-aarch64/include/stb_image.h
+- bindings/ruby/prebuilt/linux-aarch64/include/stb_image_resize2.h
+- bindings/ruby/prebuilt/linux-aarch64/include/stb_image_write.h
+- bindings/ruby/prebuilt/linux-aarch64/lib/libfastresize.a
+- bindings/ruby/prebuilt/linux-x86_64.tar.gz
+- bindings/ruby/prebuilt/linux-x86_64/bin/fast_resize
+- bindings/ruby/prebuilt/linux-x86_64/include/fastresize.h
+- bindings/ruby/prebuilt/linux-x86_64/include/stb_image.h
+- bindings/ruby/prebuilt/linux-x86_64/include/stb_image_resize2.h
+- bindings/ruby/prebuilt/linux-x86_64/include/stb_image_write.h
+- bindings/ruby/prebuilt/linux-x86_64/lib/libfastresize.a
+- bindings/ruby/prebuilt/macos-arm64.tar.gz
+- bindings/ruby/prebuilt/macos-arm64/bin/fast_resize
+- bindings/ruby/prebuilt/macos-arm64/include/fastresize.h
+- bindings/ruby/prebuilt/macos-arm64/include/stb_image.h
+- bindings/ruby/prebuilt/macos-arm64/include/stb_image_resize2.h
+- bindings/ruby/prebuilt/macos-arm64/include/stb_image_write.h
+- bindings/ruby/prebuilt/macos-arm64/lib/libfastresize.a
+- bindings/ruby/prebuilt/macos-x86_64.tar.gz
+- bindings/ruby/prebuilt/macos-x86_64/bin/fast_resize
+- bindings/ruby/prebuilt/macos-x86_64/include/fastresize.h
+- bindings/ruby/prebuilt/macos-x86_64/include/stb_image.h
+- bindings/ruby/prebuilt/macos-x86_64/include/stb_image_resize2.h
+- bindings/ruby/prebuilt/macos-x86_64/include/stb_image_write.h
+- bindings/ruby/prebuilt/macos-x86_64/lib/libfastresize.a
+- include/fastresize.h
+- include/stb_image.h
+- include/stb_image_resize2.h
+- include/stb_image_write.h
+- src/cli.cpp
+- src/decoder.cpp
+- src/encoder.cpp
+- src/fastresize.cpp
+- src/internal.h
+- src/pipeline.cpp
+- src/pipeline.h
+- src/resizer.cpp
+- src/simd_resize.cpp
+- src/simd_resize.h
+- src/simd_utils.h
+- src/thread_pool.cpp
+homepage: https://github.com/tranhuucanh/fast_resize
+licenses:
+- BSD-3-Clause
+metadata:
+  bug_tracker_uri: https://github.com/tranhuucanh/fast_resize/issues
+  changelog_uri: https://github.com/tranhuucanh/fast_resize/blob/master/CHANGELOG.md
+  documentation_uri: https://github.com/tranhuucanh/fast_resize
+  source_code_uri: https://github.com/tranhuucanh/fast_resize
+post_install_message:
+rdoc_options: []
+require_paths:
+- bindings/ruby/lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: The fastest image resizing library on the planet.
+test_files: []