/* Example: Illustrating potential lock contention */
#include <iostream>
#include <vector>
#include <thread>
#include <mutex>
#include <chrono>

std::mutex mtx;
long long shared_counter = 0;

void increment_with_lock() {
    for (int i = 0; i < 100000; ++i) {
        mtx.lock(); // Acquire lock
        shared_counter++;
        mtx.unlock(); // Release lock
    }
}

int main() {
    std::vector<std::thread> threads;
    auto start_time = std::chrono::high_resolution_clock::now();

    for (int i = 0; i < 4; ++i) { // Simulate multiple threads contending for the lock
        threads.emplace_back(increment_with_lock);
    }

    for (auto& t : threads) {
        t.join();
    }

    auto end_time = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> diff = end_time - start_time;

    std::cout << "Final Counter Value: " << shared_counter << std::endl;
    std::cout << "Execution Time (with lock): " << diff.count() << " seconds" << std::endl;

    // Consider the overhead of context switches, cache invalidations, and potential priority inversions
    // that might occur with OS-level mutexes under heavy contention.
    return 0;
}

/* Example: Conceptual Wait-Free Counter Increment using CAS */
#include <iostream>
#include <vector>
#include <thread>
#include <atomic>
#include <chrono>

std::atomic<long long> wait_free_counter(0);

void increment_wait_free() {
    for (int i = 0; i < 100000; ++i) {
        long long expected_value = wait_free_counter.load(std::memory_order_relaxed); // Read current value
        long long new_value;
        do {
            new_value = expected_value + 1;
            // Attempt to atomically update: if current value matches expected, set to new_value
            // If not, 'expected_value' is updated with the actual current value and loop retries.
        } while (!wait_free_counter.compare_exchange_weak(
            expected_value, new_value,
            std::memory_order_release, std::memory_order_acquire));
        // memory_order_release ensures preceding writes are visible before CAS
        // memory_order_acquire ensures subsequent reads see writes made before CAS
    }
}

int main() {
    std::vector<std::thread> threads;
    auto start_time = std::chrono::high_resolution_clock::now();

    for (int i = 0; i < 4; ++i) {
        threads.emplace_back(increment_wait_free);
    }

    for (auto& t : threads) {
        t.join();
    }

    auto end_time = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> diff = end_time - start_time;

    std::cout << "Final Wait-Free Counter Value: " << wait_free_counter.load() << std::endl;
    std::cout << "Execution Time (wait-free): " << diff.count() << " seconds" << std::endl;

    // Observe that this approach avoids OS context switches inherent to mutexes,
    // relying instead on CPU-level atomic instructions.
    // Note: compare_exchange_weak can spuriously fail, hence the loop.
    return 0;
}

/* Example: Conceptual Wait-Free Node Insertion (Simplified for illustration) */
#include <atomic>
#include <memory>
#include <iostream>

// A basic node structure for a list/stack
template<typename T>
struct Node {
    T data;
    std::atomic<Node<T>*> next;

    Node(T val) : data(val), next(nullptr) {}
};

// Simplified conceptual wait-free 'push' operation for a stack-like structure
// In a real wait-free structure, managing memory (ABA problem) is crucial.
template<typename T>
void push_wait_free(std::atomic<Node<T>*>& head, T value) {
    Node<T>* new_node = new Node<T>(value); // Allocate new node
    Node<T>* old_head;

    do {
        old_head = head.load(std::memory_order_relaxed); // Read current head
        new_node->next.store(old_head, std::memory_order_relaxed); // Link new node to current head
        // Attempt to replace head: if head is still old_head, set to new_node
        // Use memory_order_release for new_node->next to ensure it's visible before head updates.
        // Use memory_order_acquire for head update to ensure visibility of previous operations.
    } while (!head.compare_exchange_weak(
        old_head, new_node,
        std::memory_order_release, std::memory_order_acquire));
    
    // A real wait-free stack would require careful memory management (e.g., hazard pointers or RCU)
    // to avoid the ABA problem and ensure safe deletion of nodes without blocking.
    std::cout << "Pushed value: " << value << std::endl;
}

int main() {
    std::atomic<Node<int>*> stack_head(nullptr);

    push_wait_free(stack_head, 10);
    push_wait_free(stack_head, 20);
    push_wait_free(stack_head, 30);

    // For a complete example, one would implement pop, and proper memory reclamation.
    // Note: this example is highly simplified and lacks full robust memory management 
    // crucial for a production-ready wait-free data structure.

    // Clean up (simple for this example, complex in real wait-free structures)
    Node<int>* current = stack_head.load();
    while (current) {
        Node<int>* next_node = current->next.load();
        delete current;
        current = next_node;
    }

    return 0;
}

/* Example: Conceptual ABA Problem Illustration */
#include <atomic>
#include <iostream>
#include <thread>
#include <vector>

// Simplified node structure without proper memory management for ABA demo
struct MyNode { 
    int value; 
    MyNode* next; 
    // In a real system, this would be a tagged pointer or std::atomic<std::pair<MyNode*, int>> 
    // to include a version counter or use hazard pointers for memory reclamation.
}; 

std::atomic<MyNode*> shared_head(nullptr);

void simulate_aba_problem_thread() {
    // Thread A: Reads head 'A'
    MyNode* nodeA = shared_head.load(std::memory_order_relaxed);
    std::this_thread::sleep_for(std::chrono::milliseconds(10)); // Simulate delay

    // Another thread (Thread B, not shown) might have: 
    // 1. Popped 'A' 
    // 2. Pushed 'X' 
    // 3. Pushed 'A' back on the stack (if memory was reused)

    // Thread A now attempts CAS: if head is still 'A', set to 'null'
    // This CAS *succeeds* even though 'A' is no longer the logical head it was before.
    // 'A' might have been popped and pushed back, leading to a stale 'next' pointer or resource leak.
    if (shared_head.compare_exchange_strong(nodeA, nullptr, std::memory_order_release, std::memory_order_acquire)) {
        std::cout << "Thread A: CAS succeeded assuming head was original A. (Potential ABA!)" << std::endl;
    } else {
        std::cout << "Thread A: CAS failed. Head changed unexpectedly." << std::endl;
    }
}

int main() {
    MyNode* nodeA = new MyNode{1, nullptr};
    shared_head.store(nodeA, std::memory_order_release);

    std::thread t1(simulate_aba_problem_thread);
    // In a real scenario, another thread would execute operations that cause the ABA problem here.
    // For this simplified demo, imagine a second thread did pop A, push X, push A.

    t1.join();

    delete shared_head.load(); // Clean up if CAS failed or if 'A' was left.
    
    // To fix ABA: Use a version counter or tagged pointer in the atomic type.
    // Example: std::atomic<std::pair<MyNode*, long long>> shared_head_with_tag;
    // The tag increments with every modification, ensuring that even if the pointer is the same,
    // the logical state is different.

    std::cout << "
Mitigation strategy: Use version counters (e.g., tagged pointers) or hazard pointers."
              << std::cout << "This ensures the logical state matches the physical pointer.
" << std::endl;
    
    delete nodeA; // Ensure memory is freed, assuming nodeA was initially the head.

    return 0;
}