Blog

#include <cstdio>
#include <mutex>
#include <thread>
#include <vector>

struct NoLock {                                   // 단일 스레드용: 아무것도 안 한다
    void lock() {}
    void unlock() {}
};

struct MutexLock {
    std::mutex m;
    void lock() { m.lock(); }
    void unlock() { m.unlock(); }
};

template <typename T, typename ThreadModel = NoLock>   // 동기화 정책을 템플릿 인자로
class List {
    struct Node { T v; Node* next; };
    Node* head_ = nullptr;
    std::size_t size_ = 0;
    ThreadModel tm_;
public:
    ~List() { while (head_) { Node* n = head_->next; delete head_; head_ = n; } }
    void push_front(const T& v)
    {
        tm_.lock();
        head_ = new Node{v, head_};
        ++size_;
        tm_.unlock();
    }
    std::size_t size() const { return size_; }
};

template <typename L>
void fill_from_threads(L& list)
{
    std::vector<std::thread> ts;
    for (int t = 0; t < 4; ++t) ts.emplace_back([&] { for (int i = 0; i < 100'000; ++i) list.push_front(i); });
    for (auto& t : ts) t.join();
}

int main()
{
    List<int> single;                             // 기본 정책 NoLock
    for (int i = 0; i < 3; ++i) single.push_front(i);
    std::printf("  single: size=%zu\n", single.size());

    List<int, MutexLock> shared;
    fill_from_threads(shared);
    std::printf("  MutexLock from 4 threads: size=%zu\n", shared.size());
}

#include <chrono>
#include <cstdio>

// (1) 실행 시간 전략: 가상 함수 인터페이스
struct ISync { virtual ~ISync() = default; virtual void lock() = 0; virtual void unlock() = 0; };
struct NoSync : ISync { void lock() override {} void unlock() override {} };

struct CounterV {
    ISync* sync; long n = 0;
    void inc() { sync->lock(); ++n; sync->unlock(); }
};

// (2) 컴파일 시간 전략: 템플릿 인자
struct NoLock { void lock() {} void unlock() {} };
template <typename Sync>
struct CounterT {
    Sync sync; long n = 0;
    void inc() { sync.lock(); ++n; sync.unlock(); }
};

__attribute__((noipa)) void run_v(CounterV& c, long iters) { for (long i = 0; i < iters; ++i) c.inc(); }
__attribute__((noipa)) void run_t(CounterT<NoLock>& c, long iters) { for (long i = 0; i < iters; ++i) c.inc(); }
__attribute__((noipa)) ISync* make_sync() { static NoSync s; return &s; }   // 컴파일러가 타입을 추측하지 못하게

template <typename F>
double ms(F f) { auto t = std::chrono::steady_clock::now(); f(); return std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now() - t).count(); }

int main()
{
    const long N = 200'000'000;
    CounterV v{make_sync()};
    CounterT<NoLock> t;
    double a = ms([&] { run_v(v, N); });
    double b = ms([&] { run_t(t, N); });
    std::printf("  virtual  : %7.1f ms (n=%ld)\n", a, v.n);
    std::printf("  template : %7.1f ms (n=%ld)\n", b, t.n);
}

#include <mutex>
struct NoLock { void lock() {} void unlock() {} };
struct MutexLock { std::mutex m; void lock() { m.lock(); } void unlock() { m.unlock(); } };
template <typename T, typename TM = NoLock> class List { TM tm_; };

int main()
{
    List<int, NoLock> a;
    List<int, MutexLock> b;
    a = b;                                        // 정책이 다르면 서로 다른 타입
}

#include <cstdio>
#include <cstdlib>
#include <memory>

struct NoLock { void lock() {} void unlock() {} };
struct NoCheck { static void check(int) {} };

template <typename T, typename Lock, typename Check>
struct Plain {                                    // 빈 정책도 멤버로 두면 최소 1바이트 + 패딩
    T* data; Lock lock; Check check;
};

template <typename T, typename Lock, typename Check>
struct Packed {
    T* data;
    [[no_unique_address]] Lock lock;              // C++20: 빈 멤버가 공간을 차지하지 않게
    [[no_unique_address]] Check check;
};

struct FreeDeleter { void operator()(void* p) const { std::free(p); } };

int main()
{
    std::printf("  Plain<int,NoLock,NoCheck>  = %zu\n", sizeof(Plain<int, NoLock, NoCheck>));
    std::printf("  Packed<int,NoLock,NoCheck> = %zu\n", sizeof(Packed<int, NoLock, NoCheck>));
    // 표준 라이브러리도 정책을 템플릿 인자로 받는다
    std::printf("  unique_ptr<int, FreeDeleter>       = %zu\n", sizeof(std::unique_ptr<int, FreeDeleter>));
    std::printf("  unique_ptr<int, void(*)(void*)>    = %zu\n", sizeof(std::unique_ptr<int, void (*)(void*)>));
}

#include <concepts>
#include <cstdio>

template <typename P>
concept LockPolicy = requires(P p) { p.lock(); p.unlock(); };   // 정책이 지켜야 할 조건

struct NoLock { void lock() {} void unlock() {} };
struct BadLock { void acquire() {} void release() {} };          // 이름이 다름

template <typename T, LockPolicy TM = NoLock>
class List { TM tm_; public: void push(const T&) { tm_.lock(); tm_.unlock(); } };

int main()
{
    List<int> ok;
    ok.push(1);
    List<int, BadLock> bad;
}

#include <cstdio>
#include <cstring>
#include <string>

// 서로 독립인 두 정책: 저장 위치 x 로그 출력
struct HeapStore {
    std::string buf;
    void put(const char* s) { buf += s; }
    const char* data() const { return buf.c_str(); }
};
template <std::size_t N> struct FixedStore {     // 동적 할당 없는 버퍼 (임베디드용)
    char buf[N] = {}; std::size_t len = 0;
    void put(const char* s) { for (; *s && len + 1 < N; ++s) buf[len++] = *s; }
    const char* data() const { return buf; }
};
struct Quiet   { static void trace(const char*) {} };
struct Verbose { static void trace(const char* s) { std::printf("    trace: put \"%s\"\n", s); } };

template <typename Store, typename Log = Quiet>
class Buffer {
    Store st_;
public:
    Buffer& operator<<(const char* s) { Log::trace(s); st_.put(s); return *this; }
    const char* str() const { return st_.data(); }
};

int main()
{
    Buffer<HeapStore> a;
    a << "hello, " << "policy";
    std::printf("  heap/quiet   : %s\n", a.str());

    Buffer<FixedStore<8>, Verbose> b;             // 정책 조합만 바꿔 새 클래스
    b << "hello, " << "policy";
    std::printf("  fixed8/verbose: %s (sizeof=%zu)\n", b.str(), sizeof(b));
}