aigroup-workflow 2.1.2 → 2.2.1

package/skills/cpp-pro/references/memory-performance.md

@@ -1,397 +0,0 @@
-# Memory Management & Performance
-
-## Smart Pointers
-
-```cpp
-#include <memory>
-
-// unique_ptr - exclusive ownership
-auto create_resource() {
-    return std::make_unique<Resource>("data");
-}
-
-// shared_ptr - reference counting
-std::shared_ptr<Data> shared = std::make_shared<Data>(42);
-std::weak_ptr<Data> weak = shared;  // Non-owning reference
-
-// Custom deleters
-auto file_deleter = [](FILE* fp) { if (fp) fclose(fp); };
-std::unique_ptr<FILE, decltype(file_deleter)> file(
-    fopen("data.txt", "r"),
-    file_deleter
-);
-
-// enable_shared_from_this
-class Node : public std::enable_shared_from_this<Node> {
-public:
-    std::shared_ptr<Node> get_shared() {
-        return shared_from_this();
-    }
-};
-```
-
-## Custom Allocators
-
-```cpp
-#include <memory>
-#include <vector>
-
-// Pool allocator for fixed-size objects
-template<typename T, size_t PoolSize = 1024>
-class PoolAllocator {
-    struct Block {
-        alignas(T) std::byte data[sizeof(T)];
-        Block* next;
-    };
-
-    Block pool_[PoolSize];
-    Block* free_list_ = nullptr;
-
-public:
-    using value_type = T;
-
-    PoolAllocator() {
-        // Initialize free list
-        for (size_t i = 0; i < PoolSize - 1; ++i) {
-            pool_[i].next = &pool_[i + 1];
-        }
-        pool_[PoolSize - 1].next = nullptr;
-        free_list_ = &pool_[0];
-    }
-
-    T* allocate(size_t n) {
-        if (n != 1 || !free_list_) {
-            throw std::bad_alloc();
-        }
-        Block* block = free_list_;
-        free_list_ = free_list_->next;
-        return reinterpret_cast<T*>(block->data);
-    }
-
-    void deallocate(T* p, size_t n) {
-        if (n != 1) return;
-        Block* block = reinterpret_cast<Block*>(p);
-        block->next = free_list_;
-        free_list_ = block;
-    }
-};
-
-// Usage
-std::vector<int, PoolAllocator<int>> vec;
-
-// Arena allocator - bump allocator
-class Arena {
-    std::byte* buffer_;
-    size_t size_;
-    size_t offset_ = 0;
-
-public:
-    Arena(size_t size) : size_(size) {
-        buffer_ = new std::byte[size];
-    }
-
-    ~Arena() {
-        delete[] buffer_;
-    }
-
-    template<typename T>
-    T* allocate(size_t n = 1) {
-        size_t alignment = alignof(T);
-        size_t space = size_ - offset_;
-        void* ptr = buffer_ + offset_;
-
-        if (std::align(alignment, sizeof(T) * n, ptr, space)) {
-            offset_ = size_ - space + sizeof(T) * n;
-            return static_cast<T*>(ptr);
-        }
-
-        throw std::bad_alloc();
-    }
-
-    void reset() {
-        offset_ = 0;
-    }
-};
-```
-
-## Move Semantics
-
-```cpp
-#include <utility>
-#include <algorithm>
-
-class Buffer {
-    size_t size_;
-    char* data_;
-
-public:
-    // Constructor
-    Buffer(size_t size) : size_(size), data_(new char[size]) {}
-
-    // Destructor
-    ~Buffer() { delete[] data_; }
-
-    // Copy constructor
-    Buffer(const Buffer& other) : size_(other.size_), data_(new char[size_]) {
-        std::copy(other.data_, other.data_ + size_, data_);
-    }
-
-    // Copy assignment
-    Buffer& operator=(const Buffer& other) {
-        if (this != &other) {
-            delete[] data_;
-            size_ = other.size_;
-            data_ = new char[size_];
-            std::copy(other.data_, other.data_ + size_, data_);
-        }
-        return *this;
-    }
-
-    // Move constructor
-    Buffer(Buffer&& other) noexcept
-        : size_(other.size_), data_(other.data_) {
-        other.size_ = 0;
-        other.data_ = nullptr;
-    }
-
-    // Move assignment
-    Buffer& operator=(Buffer&& other) noexcept {
-        if (this != &other) {
-            delete[] data_;
-            size_ = other.size_;
-            data_ = other.data_;
-            other.size_ = 0;
-            other.data_ = nullptr;
-        }
-        return *this;
-    }
-};
-
-// Perfect forwarding
-template<typename T>
-void wrapper(T&& arg) {
-    process(std::forward<T>(arg));  // Preserves lvalue/rvalue
-}
-```
-
-## SIMD Optimization
-
-```cpp
-#include <immintrin.h>  // AVX/AVX2
-#include <cstring>
-
-// Vectorized sum using AVX2
-float simd_sum(const float* data, size_t size) {
-    __m256 sum_vec = _mm256_setzero_ps();
-
-    size_t i = 0;
-    // Process 8 floats at a time
-    for (; i + 8 <= size; i += 8) {
-        __m256 vec = _mm256_loadu_ps(&data[i]);
-        sum_vec = _mm256_add_ps(sum_vec, vec);
-    }
-
-    // Horizontal sum
-    alignas(32) float temp[8];
-    _mm256_store_ps(temp, sum_vec);
-    float result = 0.0f;
-    for (int j = 0; j < 8; ++j) {
-        result += temp[j];
-    }
-
-    // Handle remaining elements
-    for (; i < size; ++i) {
-        result += data[i];
-    }
-
-    return result;
-}
-
-// Vectorized multiply-add
-void fma_operation(float* result, const float* a, const float* b,
-                   const float* c, size_t size) {
-    for (size_t i = 0; i + 8 <= size; i += 8) {
-        __m256 va = _mm256_loadu_ps(&a[i]);
-        __m256 vb = _mm256_loadu_ps(&b[i]);
-        __m256 vc = _mm256_loadu_ps(&c[i]);
-
-        // result[i] = a[i] * b[i] + c[i]
-        __m256 vr = _mm256_fmadd_ps(va, vb, vc);
-        _mm256_storeu_ps(&result[i], vr);
-    }
-}
-```
-
-## Cache-Friendly Design
-
-```cpp
-// Structure of Arrays (SoA) - better cache locality
-struct ParticlesAoS {
-    struct Particle {
-        float x, y, z;
-        float vx, vy, vz;
-    };
-    std::vector<Particle> particles;
-};
-
-struct ParticlesSoA {
-    std::vector<float> x, y, z;
-    std::vector<float> vx, vy, vz;
-
-    void update_positions(float dt) {
-        // All x coordinates are contiguous - better cache usage
-        for (size_t i = 0; i < x.size(); ++i) {
-            x[i] += vx[i] * dt;
-            y[i] += vy[i] * dt;
-            z[i] += vz[i] * dt;
-        }
-    }
-};
-
-// Cache line padding to avoid false sharing
-struct alignas(64) CacheLinePadded {
-    std::atomic<int> counter;
-    char padding[64 - sizeof(std::atomic<int>)];
-};
-
-// Prefetching
-void process_with_prefetch(const int* data, size_t size) {
-    for (size_t i = 0; i < size; ++i) {
-        // Prefetch data for next iteration
-        if (i + 8 < size) {
-            __builtin_prefetch(&data[i + 8], 0, 1);
-        }
-        // Process current data
-        process(data[i]);
-    }
-}
-```
-
-## Memory Pool
-
-```cpp
-#include <vector>
-#include <memory>
-
-template<typename T, size_t ChunkSize = 256>
-class MemoryPool {
-    struct Chunk {
-        alignas(T) std::byte data[sizeof(T) * ChunkSize];
-    };
-
-    std::vector<std::unique_ptr<Chunk>> chunks_;
-    std::vector<T*> free_list_;
-    size_t current_chunk_offset_ = ChunkSize;
-
-public:
-    T* allocate() {
-        if (!free_list_.empty()) {
-            T* ptr = free_list_.back();
-            free_list_.pop_back();
-            return ptr;
-        }
-
-        if (current_chunk_offset_ >= ChunkSize) {
-            chunks_.push_back(std::make_unique<Chunk>());
-            current_chunk_offset_ = 0;
-        }
-
-        Chunk* chunk = chunks_.back().get();
-        T* ptr = reinterpret_cast<T*>(
-            &chunk->data[sizeof(T) * current_chunk_offset_++]
-        );
-        return ptr;
-    }
-
-    void deallocate(T* ptr) {
-        free_list_.push_back(ptr);
-    }
-
-    template<typename... Args>
-    T* construct(Args&&... args) {
-        T* ptr = allocate();
-        new (ptr) T(std::forward<Args>(args)...);
-        return ptr;
-    }
-
-    void destroy(T* ptr) {
-        ptr->~T();
-        deallocate(ptr);
-    }
-};
-```
-
-## Copy Elision and RVO
-
-```cpp
-// Return Value Optimization (RVO)
-std::vector<int> create_vector() {
-    std::vector<int> vec{1, 2, 3, 4, 5};
-    return vec;  // RVO applies, no copy/move
-}
-
-// Named Return Value Optimization (NRVO)
-std::string build_string(bool condition) {
-    std::string result;
-    if (condition) {
-        result = "condition true";
-    } else {
-        result = "condition false";
-    }
-    return result;  // NRVO may apply
-}
-
-// Guaranteed copy elision (C++17)
-struct NonMovable {
-    NonMovable() = default;
-    NonMovable(const NonMovable&) = delete;
-    NonMovable(NonMovable&&) = delete;
-};
-
-NonMovable create() {
-    return NonMovable{};  // Guaranteed no copy/move in C++17
-}
-
-auto obj = create();  // OK in C++17
-```
-
-## Alignment and Memory Layout
-
-```cpp
-#include <cstddef>
-
-// Control alignment
-struct alignas(64) CacheAligned {
-    int data[16];
-};
-
-// Check alignment
-static_assert(alignof(CacheAligned) == 64);
-
-// Aligned allocation
-void* aligned_alloc_wrapper(size_t alignment, size_t size) {
-    void* ptr = nullptr;
-    if (posix_memalign(&ptr, alignment, size) != 0) {
-        throw std::bad_alloc();
-    }
-    return ptr;
-}
-
-// Placement new with alignment
-alignas(32) std::byte buffer[sizeof(Data)];
-Data* obj = new (buffer) Data();
-obj->~Data();  // Manual destruction needed
-```
-
-## Quick Reference
-
-| Technique | Use Case | Benefit |
-|-----------|----------|---------|
-| Smart Pointers | Ownership management | Memory safety |
-| Move Semantics | Avoid copies | Performance |
-| Custom Allocators | Specialized allocation | Speed + control |
-| SIMD | Parallel computation | 4-8x speedup |
-| SoA Layout | Sequential access | Cache efficiency |
-| Memory Pools | Frequent alloc/dealloc | Reduced fragmentation |
-| Alignment | SIMD/cache optimization | Performance |
-| RVO/NRVO | Return objects | Zero-copy |

package/skills/cpp-pro/references/modern-cpp.md

@@ -1,304 +0,0 @@
-# Modern C++20/23 Features
-
-## Concepts and Constraints
-
-```cpp
-#include <concepts>
-
-// Define custom concepts
-template<typename T>
-concept Numeric = std::integral<T> || std::floating_point<T>;
-
-template<typename T>
-concept Hashable = requires(T a) {
-    { std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;
-};
-
-template<typename T>
-concept Container = requires(T c) {
-    typename T::value_type;
-    typename T::iterator;
-    { c.begin() } -> std::same_as<typename T::iterator>;
-    { c.end() } -> std::same_as<typename T::iterator>;
-    { c.size() } -> std::convertible_to<std::size_t>;
-};
-
-// Use concepts for function constraints
-template<Numeric T>
-T add(T a, T b) {
-    return a + b;
-}
-
-// Concept-based overloading
-template<std::integral T>
-void process(T value) {
-    std::cout << "Processing integer: " << value << '\n';
-}
-
-template<std::floating_point T>
-void process(T value) {
-    std::cout << "Processing float: " << value << '\n';
-}
-```
-
-## Ranges and Views
-
-```cpp
-#include <ranges>
-#include <vector>
-#include <algorithm>
-
-// Ranges-based algorithms
-std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
-
-// Filter, transform, take - all lazy evaluation
-auto result = numbers
-    | std::views::filter([](int n) { return n % 2 == 0; })
-    | std::views::transform([](int n) { return n * n; })
-    | std::views::take(3);
-
-// Copy to vector only when needed
-std::vector<int> materialized(result.begin(), result.end());
-
-// Custom range adaptor
-auto is_even = [](int n) { return n % 2 == 0; };
-auto square = [](int n) { return n * n; };
-
-auto pipeline = std::views::filter(is_even)
-              | std::views::transform(square);
-
-auto processed = numbers | pipeline;
-```
-
-## Coroutines
-
-```cpp
-#include <coroutine>
-#include <iostream>
-#include <memory>
-
-// Generator coroutine
-template<typename T>
-struct Generator {
-    struct promise_type {
-        T current_value;
-
-        auto get_return_object() {
-            return Generator{std::coroutine_handle<promise_type>::from_promise(*this)};
-        }
-
-        std::suspend_always initial_suspend() { return {}; }
-        std::suspend_always final_suspend() noexcept { return {}; }
-
-        std::suspend_always yield_value(T value) {
-            current_value = value;
-            return {};
-        }
-
-        void return_void() {}
-        void unhandled_exception() { std::terminate(); }
-    };
-
-    std::coroutine_handle<promise_type> handle;
-
-    Generator(std::coroutine_handle<promise_type> h) : handle(h) {}
-    ~Generator() { if (handle) handle.destroy(); }
-
-    bool move_next() {
-        handle.resume();
-        return !handle.done();
-    }
-
-    T current_value() {
-        return handle.promise().current_value;
-    }
-};
-
-// Usage
-Generator<int> fibonacci() {
-    int a = 0, b = 1;
-    while (true) {
-        co_yield a;
-        auto next = a + b;
-        a = b;
-        b = next;
-    }
-}
-
-// Async coroutine
-#include <future>
-
-struct Task {
-    struct promise_type {
-        Task get_return_object() {
-            return Task{std::coroutine_handle<promise_type>::from_promise(*this)};
-        }
-        std::suspend_never initial_suspend() { return {}; }
-        std::suspend_never final_suspend() noexcept { return {}; }
-        void return_void() {}
-        void unhandled_exception() {}
-    };
-
-    std::coroutine_handle<promise_type> handle;
-};
-
-Task async_operation() {
-    std::cout << "Starting async work\n";
-    co_await std::suspend_always{};
-    std::cout << "Resuming async work\n";
-}
-```
-
-## Three-Way Comparison (Spaceship)
-
-```cpp
-#include <compare>
-
-struct Point {
-    int x, y;
-
-    // Auto-generate all comparison operators
-    auto operator<=>(const Point&) const = default;
-};
-
-// Custom spaceship operator
-struct Version {
-    int major, minor, patch;
-
-    std::strong_ordering operator<=>(const Version& other) const {
-        if (auto cmp = major <=> other.major; cmp != 0) return cmp;
-        if (auto cmp = minor <=> other.minor; cmp != 0) return cmp;
-        return patch <=> other.patch;
-    }
-
-    bool operator==(const Version& other) const = default;
-};
-```
-
-## Designated Initializers
-
-```cpp
-struct Config {
-    std::string host = "localhost";
-    int port = 8080;
-    bool ssl_enabled = false;
-    int timeout_ms = 5000;
-};
-
-// C++20 designated initializers
-Config cfg {
-    .host = "example.com",
-    .port = 443,
-    .ssl_enabled = true
-    // timeout_ms uses default
-};
-```
-
-## Modules (C++20)
-
-```cpp
-// math.cppm - module interface
-export module math;
-
-export namespace math {
-    template<typename T>
-    T add(T a, T b) {
-        return a + b;
-    }
-
-    class Calculator {
-    public:
-        int multiply(int a, int b);
-    };
-}
-
-// Implementation
-module math;
-
-int math::Calculator::multiply(int a, int b) {
-    return a * b;
-}
-
-// Usage in other files
-import math;
-
-int main() {
-    auto result = math::add(5, 3);
-    math::Calculator calc;
-    auto product = calc.multiply(4, 7);
-}
-```
-
-## constexpr Enhancements
-
-```cpp
-#include <string>
-#include <vector>
-#include <algorithm>
-
-// C++20: constexpr std::string and std::vector
-constexpr auto compute_at_compile_time() {
-    std::vector<int> vec{1, 2, 3, 4, 5};
-    std::ranges::reverse(vec);
-    return vec[0]; // Returns 5
-}
-
-constexpr int value = compute_at_compile_time();
-
-// constexpr virtual functions (C++20)
-struct Base {
-    constexpr virtual int get_value() const { return 42; }
-    constexpr virtual ~Base() = default;
-};
-
-struct Derived : Base {
-    constexpr int get_value() const override { return 100; }
-};
-```
-
-## std::format (C++20)
-
-```cpp
-#include <format>
-#include <iostream>
-
-int main() {
-    std::string msg = std::format("Hello, {}!", "World");
-
-    // Positional arguments
-    auto text = std::format("{1} {0}", "World", "Hello");
-
-    // Formatting options
-    double pi = 3.14159265;
-    auto formatted = std::format("Pi: {:.2f}", pi); // "Pi: 3.14"
-
-    // Custom types
-    struct Point { int x, y; };
-}
-
-// Custom formatter
-template<>
-struct std::formatter<Point> {
-    constexpr auto parse(format_parse_context& ctx) {
-        return ctx.begin();
-    }
-
-    auto format(const Point& p, format_context& ctx) const {
-        return std::format_to(ctx.out(), "({}, {})", p.x, p.y);
-    }
-};
-```
-
-## Quick Reference
-
-| Feature | C++17 | C++20 | C++23 |
-|---------|-------|-------|-------|
-| Concepts | - | ✓ | ✓ |
-| Ranges | - | ✓ | ✓ |
-| Coroutines | - | ✓ | ✓ |
-| Modules | - | ✓ | ✓ |
-| Spaceship | - | ✓ | ✓ |
-| std::format | - | ✓ | ✓ |
-| std::expected | - | - | ✓ |
-| std::print | - | - | ✓ |
-| Deducing this | - | - | ✓ |