HN 日本語サマリー

← 一覧へ戻る
プログラミング

C言語におけるGo風の並行処理

Go-Flavored Concurrency in C (antonz.org)

28 pointsby ibobev6 コメント

要約

この記事は、C言語でGo言語の並行処理モデルにどれだけ近づけるかを検証しています。Goの軽量なゴルーチンとチャネルの概念を、POSIXスレッド(pthreads)とmutex/条件変数を用いてC言語で再現するアプローチを探求しています。著者は、Goの並行処理の利点と、C言語での実装におけるトレードオフやパフォーマンスの考慮事項について解説し、最終的にはpthreadsベースのモデルで多くのことが可能であることを示唆しています。

全文翻訳

C言語におけるGo風の並行処理

Go言語の並行処理は、人々がこの言語を好む主な理由の一つです。go f()と記述し、チャネルを通じて値を送信すると、ランタイムスケジューラが少数のOSスレッド上で数千ものゴルーチンを実行します。それは手間いらずのように感じられます。

C言語にはそのような仕組みは一切ありません。これが、POSIXスレッドだけを使ってGoの並行処理モデルにどれだけ近づけるかを疑問に思わせました。明らかに、ネイティブOSスレッドは軽量ゴルーチンの効率には及びませんが、実際のコストはどれくらいで、いつ問題になるのか、そしてそれを少なくとも部分的に回避する方法はあるのでしょうか?

これらの疑問に直面したのは、ランタイムもガベージコレクタも持たない、プレーンなC言語に変換されるGoの厳密なサブセットであるSolodに並行処理を追加しているときでした。最終的に、トレードオフを正直に理解している限り、pthreadsでかなりのことができると結論付けました。

この記事は、私が選択したPOSIXスレッドベースの並行処理モデル、それが提供する利点、そしてその限界についてです。

Mutex/Cond • Atomics • Pool • Channel • Performance • Design • Wrapping up

Mutex/Cond

Solodの並行処理スタックのすべては、2つの基本的なPOSIXプリミティブ、つまりミューテックスと条件変数の上に構築されています。sync.Mutexはpthread_mutex_tの薄いラッパーです。

// Solodのstdlibソースコードから抽出。
type Mutex struct {
    mu pthread_mutex_t
}

func (m *Mutex) Lock() {
    rc := pthread_mutex_lock(&m.mu)
    if rc != 0 {
        panic("sync: Mutex.Lock failed")
    }
}

SolodはCに変換されるため、これは基本的にpthread_mutex_tを保持する構造体とpthread_mutex_lockを呼び出す関数です。以下がトランスパイラ出力です。

// 変換されたCコード。
typedef struct sync_Mutex {
    pthread_mutex_t mu;
} sync_Mutex;

void sync_Mutex_Lock(sync_Mutex* m) {
    int rc = pthread_mutex_lock(&m->mu);
    if (rc != 0) {
        so_panic("sync: Mutex.Lock failed");
    }
}

これは完全な変換です — 生成されたCコードはSolodコードのほぼ機械的な鏡であり、ただ冗長なだけです。ここからは、主にSolodバージョンを示しますが、興味のある方のためにCコードも提供します。

ここにはエキサイティングなものはありません。sync.Mutexは、問題が発生した場合(まれですが)にパニックするpthreadミューテックスのラッパーです。

対になるプリミティブはsync.Condで、pthread_cond_tのラッパーです。これは、ミューテックスに関連付けられた「条件が満たされるまで待つ」という標準的なツールです。

type Cond struct           // pthread_cond_t + pthread_mutex_t をラップ
func (c *Cond) Wait()      // pthread_cond_wait をラップ
func (c *Cond) Signal()    // pthread_cond_signal をラップ
func (c *Cond) Broadcast() // pthread_cond_broadcast をラップ

変換されたCコードを表示

typedef struct sync_Cond {
    pthread_cond_t cond;
    sync_Mutex*    mu;
} sync_Cond;

void sync_Cond_Wait(sync_Cond* c);      // pthread_cond_wait をラップ
void sync_Cond_Signal(sync_Cond* c);    // pthread_cond_signal をラップ
void sync_Cond_Broadcast(sync_Cond* c); // pthread_cond_broadcast をラップ

これら2つの型 — MutexとCond — が基盤です。他の並行処理ツール — Once、スレッドプール、チャネル — は、1つ以上のミューテックスと条件変数を使用して構築されます。これにはパフォーマンスにいくつかの影響があります。後で確認します。

Atomics

すべてにロックが必要なわけではありません。Solodのsync/atomicはGoのそれに倣っています。Bool、Int32、Int64、Uint32、Uint64、そしてジェネリックなPointer[T]があり、すべてLoad、Store、Swap、CompareAndSwapメソッドを備えています。

良い点は、これらはpthreadsをまったく必要としないことです。これらはCコンパイラの__atomic組み込み関数に直接マッピングされます — Goのコンパイラが出力するのと同じハードウェア命令です。そのため、遅くなる理由はありません。

Atomic opGoSolodWinner
Load2ns2ns~same
Store2ns2ns~same
CompareAndSwap13ns13ns~same

各数値は、単一スレッドでの1回の操作のコストです。

sync.Onceはアトミックを効果的に使用する良い例です。その高速パスは単一のアトミックロードしか必要としません — 与えられた関数が実行された後、将来のDoの呼び出しはすべてフラグをチェックして返ります。

type Once struct {
    mu   Mutex
    done atomic.Bool
}

// Do は、この o に対して初めて Do が呼び出された場合にのみ f を呼び出します。
func (o *Once) Do(f func()) {
    if o.done.Load() { // ロックフリーの高速パス
        return
    }
    // 低速パス...
}

変換されたCコードを表示

typedef struct sync_Once {
    sync_Mutex mu;
    atomic_Bool done;
} sync_Once;

// Do は、この o に対して初めて Do が呼び出された場合にのみ f を呼び出します。
void sync_Once_Do(sync_Once* o, void (*f)()) {
    if (atomic_Bool_Load(&o->done)) { // ロックフリーの高速パス
        return;
    }
    // 低速パス...
}

Worker pool

実際にコードを並行して実行するには、スレッドが必要です。conc.Thread型はpthread_tとその関連関数をラップします。

type Thread struct          // pthread_t をラップ
func (th Thread) Wait() any // pthread_join をラップ
func (th Thread) Detach()   // pthread_detach をラップ

変換されたCコードを表示

typedef struct conc_Thread {
    pthread_t t;
} conc_Thread;

void* conc_Thread_Wait(conc_Thread th);   // pthread_join をラップ
void  conc_Thread_Detach(conc_Thread th); // pthread_detach をラップ

このconc.Go関数を考えてみてください。

// Go はOSスレッドを起動し、fn(arg) を実行してそのハンドルを返します。
func Go(entry func(any) any, arg any) Thread {
    var th Thread
    rc := pthread_create(&th.t, nil, entry, arg)
    // ...
}

変換されたCコードを表示

// Go はOSスレッドを起動し、fn(arg) を実行してそのハンドルを返します。
// Solod の `any` はC言語の `void*` に変換されます。
conc_Thread conc_Go(void* (*entry)(void*), void* arg) {
    conc_Thread th = {0};
    int rc = pthread_create(&th.t, NULL, entry, arg);
    // ...
}

使用例:

func work(arg any) any {
    acc := arg.(*Account)
    // ...
}

func main() {
    var acc Account
    th := conc.Go(work, &acc)
    // ... 他の作業を並行して行う ...
    th.Wait() // Wait が返ると work は完了しています
}

変換されたCコードを表示

void* work(void* arg) {
    main_Account* acc = (main_Account*)arg;
    // ...
}

int main(void) {
    main_Account acc = {0};
    conc_Thread th = conc_Go(work, &acc);
    // ... 他の作業を並行して行う ...
    conc_Thread_Wait(th); // Wait が返ると work は完了しています
}

go work(&acc)のように見えるかもしれませんが、それは表面上の話です。conc.Goは実際のOSスレッドを起動するのであって、ゴルーチンではありません。リソースリークを防ぐために、最終的にWaitを呼び出して結合するかDetachする必要があります。また、OSスレッドの作成はコストがかかります — スタックに数キロバイトしか必要とせず、ナノ秒で起動するGoのゴルーチンとは全く異なります。

まさに、ループ内でGoを呼び出すべきではない理由です。短命なタスクや頻繁に発生するタスクには、長命なワーカー・スレッドのプールを使用し、それらにタスクを送信する方が良いです。

conc.Poolが役立ちます。

   Solod におけるワーカー・スレッド・プール
┌────────┐ ┌────────┐   ┌────────┐
│ Task 1 │ │ Task 2 │...│ Task M │  M 個のタスク
└────────┘ └────────┘   └────────┘
┌────────────────────────────────┐
│           conc.Pool            │  コーディネーター
└────────────────────────────────┐
┌────────┐ ┌────────┐   ┌────────┐
│ Thrd 1 │ │ Thrd 2 │...│ Thrd N │  N 個のスレッド、N << M
└────────┘ └────────┘   └────────┘
┌────────────────────────────────┐
│          OS scheduler          │
└────────────────────────────────┐

使用例:

type Task struct {
    in  int
    out int
}

func square(arg any) {
    task := arg.(*Task)
    task.out = task.in * task.in
}

func main() {
    tasks := make([]Task, 10)

    opts := conc.PoolOpts{NumThreads: 2}
    pool := conc.NewPool(mem.System, opts)
    defer pool.Free()

    for i := range tasks {
        tasks[i].in = i
        pool.Go(square, &tasks[i])
    }
    pool.Wait()
}

変換されたCコードを表示

typedef struct main_Task {
    so_int in;
    so_int out;
} main_Task;

void square(void* arg) {
    main_Task* task = (main_Task*)arg;
    task->out = task->in * task->in;
}

int main(void) {
    so_Slice tasks = so_make_slice(main_Task, 10, 10);

    conc_PoolOpts opts = (conc_PoolOpts){.NumThreads = 2};
    conc_Pool* pool = conc_NewPool(mem_System, opts);

    for (so_int i = 0; i < so_len(tasks); i++) {
        // so_at は、型消去されたスライスから特定の型 (ここでは main_Task) の i 番目の要素を取得する汎用マクロです。
        // ここでは、tasks スライスの i 番目のタスクを取得しています。
        so_at(main_Task, tasks, i).in = i;
        conc_Pool_Go(pool, square, &so_at(main_Task, tasks, i));
    }
    conc_Pool_Wait(pool);
    conc_Pool_Free(pool);
}

NewPoolの最初の引数、mem.Systemはメモリallocatorです。Solodは隠れたアロケーションを避けるため、メモリを必要とするものはすべてallocatorを明示的に受け取ります — ここではプールのタスクキューをバックアップしています。

内部的には、Poolは共有キュー(リングバッファ)からタスクをプルする固定数のワーカー・スレッドのグループです。これは1つのミューテックスといくつかの条件変数を使用します。

// Pool は、タスク func(any) を実行する待機キューを持つ、ワーカー・スレッドのバウンド・プールです。
type Pool struct {
    alloc mem.Allocator

    mu       sync.Mutex
    notEmpty sync.Cond // タスクがエンキューされたときにシグナルされる
    notFull  sync.Cond // スロットが解放されたときにシグナルされる
    allDone  sync.Cond // 実行中のタスクがないときにブロードキャストされる

    workers []Thread
    queue   []task // サブミットされたタスクのリングバッファ
    active  int    // サブミットされたがまだ完了していないタスク
    stopped bool   // Free で設定され、ドレインして終了する
}

// NewPool は、指定された数のワーカー・スレッドでプールを作成し、それらを起動します。
func NewPool(alloc mem.Allocator, opts PoolOpts) *Pool

// Go はタスクの実行をサブミットし、キューがいっぱいの場合にブロックします。
func (p *Pool) Go(fn func(any), arg any)

// Wait は、サブミットされたすべてのタスクが完了するまでブロックします。
func (p *Pool) Wait()

変換されたCコードを表示

// Pool は、タスク func(any) を実行する待機キューを持つ、ワーカー・スレッドのバウンド・プールです。
typedef struct conc_Pool {
    mem_Allocator alloc;

    sync_Mutex mu;
    sync_Cond  notEmpty; // タスクがエンキューされたときにシグナルされる
    sync_Cond  notFull;  // スロットが解放されたときにシグナルされる
    sync_Cond  allDone;  // 実行中のタスクがないときにブロードキャストされる

    so_Slice workers;
    so_Slice queue;      // サブミットされたタスクのリングバッファ
    so_int   active;     // サブミットされたがまだ完了していないタスク
    bool     stopped;    // Free で設定され、ドレインして終了する
} conc_Pool;

conc_Pool* conc_NewPool(mem_Allocator alloc, conc_PoolOpts opts);
void       conc_Pool_Go(conc_Pool* p, void (*fn)(void*), void* arg);
void       conc_Pool_Wait(conc_Pool* p);

notEmptyはタスクがあるときにワーカーを起こし、notFullはキューがいっぱいの場合にバックプレッシャーをかけ、allDoneはWaitがすべて完了したことを知らせます。これは古典的なプロデューサー・コンシューマー設定で、約200行のコードであり、特別なことは何もありません。

プールの心臓部はワーカーループです。各スレッドはタスクが現れるまでブロックし、ロックの外でそれを実行するためワーカーは並列に実行され、その後完了を記録します。

// workerMain は各プール・スレッドで実行されます: タスクを取得し、実行し、繰り返します。
func workerMain(arg any) any {
    p := arg.(*Pool)
    for {
        p.mu.Lock()
        for p.qempty() && !p.stopped {
            p.notEmpty.Wait() // タスクがエンキューされるまでスリープ
        }
        if p.qempty() && p.stopped {
            p.mu.Unlock()
            break // キューがドレインされ、プールがシャットダウン中
        }
        t := p.qpop()
        p.notFull.Signal() // 待機中のサブミッターのためにスロットが解放された
        p.mu.Unlock()

        t.fn(t.arg) // ロックを解放してタスクを実行

        p.mu.Lock()
        p.active--
        if p.active == 0 {
            p.allDone.Broadcast() // Wait で待機中のものを起こす
        }
        p.mu.Unlock()
    }
    return nil
}

変換されたCコードを表示

// workerMain は各プール・スレッドで実行されます: タスクを取得し、実行し、繰り返します。
static void* workerMain(void* arg) {
    conc_Pool* p = (conc_Pool*)arg;
    for (;;) {
        sync_Mutex_Lock(&p->mu);
        for (; conc_Pool_qempty(p) && !p->stopped;) {
            sync_Cond_Wait(&p->notEmpty); // タスクがエンキューされるまでスリープ
        }
        if (conc_Pool_qempty(p) && p->stopped) {
            sync_Mutex_Unlock(&p->mu);
            break; // キューがドレインされ、プールがシャットダウン中
        }
        task t = conc_Pool_qpop(p);
        sync_Cond_Signal(&p->notFull); // 待機中のサブミッターのためにスロットが解放された
        sync_Mutex_Unlock(&p->mu);

        t.fn(t.arg); // ロックを解放してタスクを実行

        sync_Mutex_Lock(&p->mu);
        p->active--;
        if (p->active == 0) {
            sync_Cond_Broadcast(&p->allDone); // Wait で待機中のものを起こす
        }
        sync_Mutex_Unlock(&p->mu);
    }
    return NULL;
}

これがプールと通常のキューを分けるものです。Pool.Goはエンキュー時にactiveをインクリメントします。各ワーカーはタスク実行後にそれをデクリメントし、最後に終了したものがallDoneをブロードキャストします。

Pool.Waitはカウントがゼロになるまでブロックします。

// Wait は、サブミットされたすべてのタスクが完了するまでブロックします。
func (p *Pool) Wait() {
    p.mu.Lock()
    for p.active != 0 {
        p.allDone.Wait()
    }
    p.mu.Unlock()
}

変換されたCコードを表示

// Wait は、サブミットされたすべてのタスクが完了するまでブロックします。
void conc_Pool_Wait(conc_Pool* p) {
    sync_Mutex_Lock(&p->mu);
    for (; p->active != 0;) {
        sync_Cond_Wait(&p->allDone);
    }
    sync_Mutex_Unlock(&p->mu);
}

トレードオフは、ワーカー・スレッドの数が固定されていることです。Goでは、ブロックされたゴルーチンは非常に少ないメモリしか使用しないため、プログラムは数千もの並行I/O待機を処理できます。Solodプールはこれを行うことができません — すべてのN個のワーカーがブロックされたシステムコールで待機している場合、プールは1つが戻るまで停止します。ランタイムに管理させるのではなく、ワークロードに基づいてプールサイズを設定する必要があります。

Channel

チャネルはGoの並行処理モデルの重要な部分であり、Solodのconc.Chan[T]はそれに非常に似たものを提供します。Goと同様に、値をコピーで渡し、バッファ付きとバッファなしの2種類があります。

ch := conc.NewChan[int](mem.System, 2) // バッファ付き、容量2
defer ch.Free()

// 独自の スレッド上のプロデューサー。
prod := producer{ch: &ch, n: 5}
thr := conc.Go(produce, &prod)
defer thr.Wait()

// チャネルが閉じられ、ドレインされるまで消費します。
var v int
for ch.Recv(&v) {
    fmt.Printf("received %d\n", v)
}

変換されたCコードを表示

// conc_NewChan, conc_Chan_Recv, およびそれらに類するものはジェネリックマクロです。
// 要素の型 (ここでは so_int) が最初の引数として渡されます。
conc_Chan ch = conc_NewChan(so_int, mem_System, 2); // バッファ付き、容量2

// 独自の スレッド上のプロデューサー。
producer prod = (producer){.ch = &ch, .n = 5};
conc_Thread thr = conc_Go(produce, &prod);

// チャネルが閉じられ、ドレインされるまで消費します。
so_int v = 0;
for (; conc_Chan_Recv(so_int, &ch, &v);) {
    fmt_Printf("received %d\n", v);
}

conc_Thread_Wait(thr);
conc_Chan_Free(so_int, &ch);

Chan[T]は、作成時に選択される2つのエンジンのいずれかをラップする薄いジェネリックシェルです。

バッファ付き (n > 0) は、notEmptyとnotFull条件変数を持つミューテックスで保護されたリングバッファです — Poolキューのようなものです。送信者は満杯時にブロックし、受信者は空の時にブロックします。

type Buffer struct {
    alloc mem.Allocator

    mu       sync.Mutex
    notEmpty sync.Cond // アイテムが利用可能になったときにシグナルされる
    notFull  sync.Cond // スロットが解放されたときにシグナルされる

    buf    mem.Array   // リングバッファ
    closed bool        // Close 後は true
}

// Send は v をリングにコピーし、満杯の場合はブロックします。
func (ch *Buffer) Send(v any) {
    ch.mu.Lock()
    for ch.bfull() {
        ch.notFull.Wait() // スロットが解放されるまでバックプレッシャー
    }
    ch.bpush(v)
    ch.notEmpty.Signal() // 待機中の受信者を1人起こす
    ch.mu.Unlock()
}

変換されたCコードを表示

typedef struct conc_Buffer {
    mem_Allocator alloc;

    sync_Mutex mu;
    sync_Cond  notEmpty; // アイテムが利用可能になったときにシグナルされる
    sync_Cond  notFull;  // スロットが解放されたときにシグナルされる

    mem_Array buf;       // リングバッファ
    bool closed;         // Close 後は true
} conc_Buffer;

// Send は v をリングにコピーし、満杯の場合はブロックします。
void conc_Buffer_Send(conc_Buffer* ch, void* v) {
    sync_Mutex_Lock(&ch->mu);
    for (; conc_Buffer_bfull(ch);) {
        sync_Cond_Wait(&ch->notFull); // スロットが解放されるまでバックプレッシャー
    }
    conc_Buffer_bpush(ch, v);
    sync_Cond_Signal(&ch->notEmpty); // 待機中の受信者を1人起こす
    sync_Mutex_Unlock(&ch->mu);
}

完全な実装ではclosedもチェックしますが、簡潔さのために省略しました。

Recvは対になるメソッドです:空の場合はブロックし、次の値を取り出し、送信者を起こすためにnotFullをシグナルします。また、クローズされたチャネルも処理し、バッファがクローズされてドレインされた後にfalseを返します。残りは、このロック・待機・シグナルの中核です。

Buffer ソースコード

バッファなし (n == 0) は、ランデブーです:各送信は、受信者が値を受け取るまでブロックし、中間バッファを使用せずに送信者のスタックから受信者の宛先までvsizeバイトを直接コピーします。

type Rendezvous struct {
    alloc mem.Allocator
    vsize int // ハンドオフされる値のバイトサイズ

    mu   sync.Mutex
    cond sync.Cond // すべてのスロット状態変更時にブロードキャスト

    src     any  // 送信者の公開された値 (フル時に有効)
    full    bool // 値が公開され、まだ解放されていない
    claimed bool // 公開された値が受信者によって取得された
    closed  bool // Close 後は true
}

// Send は v を公開し、受信者がそれを受け取るのを待ちます。
func (ch *Rendezvous) Send(v any) {
    ch.mu.Lock()
    for ch.full {
        ch.cond.Wait()  // 前回のハンドオフが完了するのを待つ
    }
    ch.src, ch.full, ch.claimed = v, true, false // 公開
    ch.cond.Broadcast() // ウェイクアップ #1: 受信者を起こす
    for !ch.claimed {
        ch.cond.Wait()  // 値が取得されるまで待つ
    }
    ch.src, ch.full = nil, false // スロットを解放
    ch.cond.Broadcast()
    ch.Unlock()
}

変換されたCコードを表示

typedef struct conc_Rendezvous {
    mem_Allocator alloc;
    so_int vsize; // ハンドオフされる値のバイトサイズ

    sync_Mutex mu;
    sync_Cond  cond; // すべてのスロット状態変更時にブロードキャスト

    void* src;     // 送信者の公開された値 (フル時に有効)
    bool  full;    // 値が公開され、まだ解放されていない
    bool  claimed; // 公開された値が受信者によって取得された
    bool  closed;  // Close 後は true
} conc_Rendezvous;

// Send は v を公開し、受信者がそれを受け取るのを待ちます。
void conc_Rendezvous_Send(conc_Rendezvous* ch, void* v) {
    sync_Mutex_Lock(&ch->mu);
    for (; ch->full;) {
        sync_Cond_Wait(&ch->cond);  // 前回のハンドオフが完了するのを待つ
    }
    ch->src = v;                    // 公開
    ch->full = true;
    ch->claimed = false;
    sync_Cond_Broadcast(&ch->cond); // ウェイクアップ #1: 受信者を起こす
    for (; !ch->claimed;) {
        sync_Cond_Wait(&ch->cond);  // 値が取得されるまで待つ
    }
    ch->full = false;               // スロットを解放
    ch->src = NULL;
    sync_Cond_Broadcast(&ch->cond);
    sync_Mutex_Unlock(&ch->mu);
}

Recvはもう一方の半分です:公開され、取得されていない値を待ち、送信者のスタックからdstにvsizeバイトを直接コピーし(中間バッファなし)、取得済みとしてマークし、送信者を起こすためにブロードキャストしてウェイクアップ#2を作成します。1回のハンドオフ、2回のウェイクアップ。

送信者のスタックから直接コピーするのは、2回目のウェイクアップのおかげで安全です。srcはvへのポインタであり、これは送信者のスタック上に存在します。受信者がそれを読み取っている間、送信者はfor !ch.claimed { ch.cond.Wait() }で待機しているため、そのスタックフレームは生存し続けます。送信者は、受信者がclaimedを設定してウェイクアップをトリガーした後になって初めて戻り(そしてそのメモリを再利用)ます。ソースが読み取りよりも長く存続することが保証されているため、共有バッファにコピーする必要はありません。

Rendezvous ソースコード

ご覧のとおり、APIはGoと非常に似ています。では、数値を見てみましょう。

Performance

これが主なトレードオフです:pthreadベースの並行処理プリミティブは、誰もブロックする必要がない場合は高速ですが、ブロックする必要がある場合は遅くなります。そして、その理由は常に同じです。

Goはユーザー空間でゴルーチンをスケジューリングします。1つのゴルーチンがチャネルでブロックし、別のゴルーチンがそれを起こすとき、ランタイムはそれらを独自のキュー間で移動します — カーネルは関与しません。一方、POSIXスレッドはユーザーランドスケジューラを提供しません。スレッドが条件変数でブロックすると、カーネルで待機状態になり、それを起こすにはシステムコールが必要です。実際にブロックするスレッド間のすべてのハンドオフは、両端でシステムコールのコストを支払います。

ミューテックスベンチマークの違いは明らかです。8つの競合するスレッドでは、待機スレッドが待機する必要があるかどうかにすべてがかかっています。

Mutex benchmarkGoSolodWinner
Uncontended, 1 thread14ns9nsSolod - 1.6x
Contended spin, 8 threads75ns27nsSolod - 2.8x
Contended work, 8 threads1.1µs2.0µsGo - 1.8x

各数値は、単一のLock/Unlockペアの平均時間です。アンコンテンデッドベンチマークは1つのスレッドで実行され、コンテンデッドベンチマークは複数のスレッドが同じミューテックスを争います。

Solodが最初の2つのベンチマークで実際に勝利していることに注意してください。それには十分な理由があります。SolodのLockは、余分なものがないプレーンなpthread_mutex_lock呼び出しですが、Goのsync.Mutexは、スターベーションモードの追跡や、クリティカルセクションの途中でゴルーチンがプリエンプトされる可能性があるため関与し続けるランタイムなど、さらに多くのオーバーヘッドを追加します。

誰もブロックしない場合、そのオーバーヘッドが主なコストであり、より薄いラッパーはハードウェアに近いものです。空のクリティカルセクション(スピンベンチマーク)では、待機スレッドはロックをほとんどブロックせずに取得するため、Solodが2.8倍の差で勝利します。アンコンテンデッドベンチマーク(単一スレッド、競合なし)も同様です。呼び出しとロックの間のコードが少ないため、9ns対14nsです。

スレッドがブロックする必要がある瞬間に、状況は反転します。クリティカルセクションに約1マイクロ秒の実作業(ワークベンチマーク)を与えると、待機者はスピン予算を使い果たしてブロックします。今や、すべてのハンドオフはウェイクアップシステムコールを必要とし、SolodはGoのスループットの半分に低下します。作業は両方のケースで同一です — 違いは、ブロックするコストから来ています。

条件変数は、常にブロックするため、これを明確に示しています。

Cond benchmarkGoSolodWinner
1 waiter150ns1.5µsGo - 10x
8 waiters2.0µs14µsGo - 7.0x
32 waiters9.0µs60µsGo - 6.7x

各数値は、1回のランデブーラウンドのコストです:すべての待機者を起こし、制御を戻す1回のブロードキャスト、N人の待機者と1人のブロードキャスター。

Pthreadベースの条件変数は一貫して7〜10倍遅いです。このギャップを埋めるトリックはありません — それは単に実際のOSスレッドを起こすコストであり、ゴルーチンを起こすコストではありません。

チャネルも同様の問題を抱えています。なぜなら、それらはミューテックスと条件変数を使用して構築されているからです。

Chan benchmarkGoSolodWinner
Uncontended, 1 thread24ns21nsSolod - 1.1x
Unbuffered, 2 threads130ns3.0µsGo - 23x
Buffered (10), 2 threads44ns400nsGo - 9.1x
Buffered (100), 2 threads33ns70nsGo - 2.1x

各数値は、チャネルを介して1つの値を移動するコスト(送信とそれに一致する受信)です。括弧内の数値はバッファ容量です。

アンコンテンデッドケースは、単一スレッドからバッファを埋めてドレインするため、何もブロックしません — 単なるロックとコピーであり、Solodにわずかな利点をもたらします。しかし、プロデューサーとコンシューマーが実際に作業の受け渡しを開始すると、Solodはブロックされる転送ごとにスレッドを起こす必要があり、パフォーマンスは低下します。これはバッファなしチャネルで最悪で、すべての値が2回のウェイクアップを伴うランデブーです:23倍遅いです。より大きなバッファは大きく役立ちます — 100個のアイテムを格納する容量があれば、ほとんどの送信は誰も起こさずに通過し、ギャップは約2倍に縮まります。

結果として、タスクが大きければ大きいほど、pthreadベースの並行処理はうまく機能します。スレッド間の細粒度の、値ごとのストリーミングにチャネルを使用すると、パフォーマンスは低下します。しかし、プールに作業アイテム全体を渡すためにチャネルを使用し、各アイテムの処理に数十マイクロ秒かかる場合、ウェイクアップコストは無視できるものになります。現実的なワークロードでのプールベンチマークがこれを裏付けています。

Pool benchmarkGoSolodWinner
1000 CPU tasks (~40µs each)7ms8msGo - 1.1x
64 IO tasks (1ms block each)9ms10msGo - 1.1x

各数値は、8人のワーカーがバッチ全体を処理するのにかかった壁時計時間です。

ここでは、SolodはGoの1.1倍以内に収まっています。タスクごとのディスパッチコストは依然として存在しますが、実際の作業に分散されており、パフォーマンスのペナルティはかなり小さいです。

ベンチマーク

すべてのベンチマークは、macOSで実行されているApple M1 CPUで実行されました。CコードはClang 16を使用して、これらのCFLAGSとシステムallocatorとしてmimallocでコンパイルされました。

-Ofast -march=native -flto -funroll-loops -DNDEBUG

表示されている結果は、複数のベンチマーク実行からのメディアンです。各ベンチマークは、Go自身のベンチマークと同じロジックに従って、多くのイテレーションを実行しました。

GoのベンチマークはGo 1.26とgo test -bench=.を使用しました。

SolodとGoの両方のベンチマークのソースコード:conc • sync

pthreadベースのアプローチの長所と短所の概要を以下に示します。

  • ➕ 粗粒度のプールされたワークロードは、Goのパフォーマンスの約10%以内に収まります。
  • ➕ アンコンテンデッドロックとスピンフレンドリーなクリティカルセクションは非常にうまく機能します。
  • ➕ アトミック操作はGoと同じくらい高速です。
  • ➕ 実装は100倍シンプルです。
  • ➖ ブロックしてOSスレッドを起こす必要があるものは、Goのユーザー空間スケジューラよりもはるかに遅いです。
  • ➖ プールは、ゴルーチンのように数千ものブロックされた待機者を処理できません。

「数千もの安価なゴルーチン」を探しているなら、pthreadベースのアプローチは期待外れになるでしょう。しかし、「少数のワーカー・スレッドが多くのタスクを処理する」ことに満足しているなら、それはうまく機能します。

Design decisions

Solodで並行処理を実装する方法に影響を与えた3つの決定があります。

Pthreads、ファイバーではない。カーネルのウェイクアップコストを回避するコルーチン/ファイバーライブラリがCには存在することを知っています — necoのようなシングルスレッドのもの、そしてlibfiberのようなマルチスレッドのもの。ユーザー空間スケジューラは、上記のベンチマークでGoに匹敵するために役立つものです。

私はそれを使用しないことにしました。私は非常にシンプルなものを求めていました — 1つの段落で説明できるアプローチで、すべてのCプログラマーがすでに知っているツールを使用します。トレードオフは、細粒度のブロッキングでパフォーマンスが低下することですが、多くの実際の状況では、ワーカープールを使用すればpthreadsはうまく機能します。少なくとも私にとっては、タスクのハンドオフ中の数マイクロ秒を節約するよりも、単純さを保つことの方が重要です。今のところは。

標準ライブラリ、言語ではない。Goはゴルーチン、チャネル、セレクトを言語に直接組み込んでいます。私は2つの理由で、すべてをstdlibに保つことにしました。

➀ それはSolodの「隠れたアロケーションなし」ルールに従います。Goでは、go f()は静かにゴルーチンスタックをアロケートし、make(chan T, n)はバッファをアロケートします。Solodでは、すべてのアロケーションは明示的です:NewChanとNewPoolにallocatorを渡し、メモリの出所を常に正確に把握します — それがシステムallocatorであれ、アリーナであれ、あるいは他のものであれ。

➁ ライブラリはより柔軟です。プールは通常の値なので、必要に応じていくつでも持つことができ、それぞれが特定の目的に合わせてサイズ調整されています。各ステージが異なる容量を必要とするマルチステージパイプラインでは、ステージごとに1つのプールを開始でき、それぞれに独自のNumThreadsとQueueSizeがあり、単一のグローバルスケジューラを与えられるのではなく。言語はシンプルに保たれ、柔軟性は簡単に読めるコードにあります。

タイムアウト、セレクトではない。Goのselectは複数のチャネル操作を一度に待ち、最初に準備ができたものに進みます。それを実装するにはかなりの作業が必要でした — スレッドは複数のチャネルへの関心を登録し、一度ブロックし、それらのいずれかが準備できたときにウェイクアップする必要があります — なので私はそれを省略しました。代わりに、ChanはSendTimeoutとRecvTimeoutを提供しており、これらは単一チャネルでのselectの2つの一般的な使用法をカバーしています。

  • 「これを実行するが、しばらくしたら諦める」(Goのcase <-time.After(...)イディオム)。
  • 「ブロックしない場合にのみこれを実行する」(Goのノンブロッキングdefaultブランチ)。

欠けているのは、複数のチャネルに同時にブロックし、最初に準備ができたものに進む機能、および同じ選択で送信と受信を混在させるオプションです。

Wrapping up

pthreadsだけを使ってGoの並行処理にどれだけ近づけるか?有用な程度には近づけますが、本当にGoに匹敵するほどではありません。ミューテックス、条件変数、プール、チャネルといった馴染みのあるAPIで実際のOSスレッドをラップでき、コードはGoのように見え、動作します。少なくともスレッドがブロックする必要があるまでは。しかし、その下にはスケジューラがないため、スレッドがブロックするときは、カーネルで待機している実際のスレッドであり、無料で一時停止されているゴルーチンではありません。それがこのアプローチの主な限界です。

その見返りに得られるのは、驚くほどの単純さです。すべてのプリミティブは、ランタイムが背後にあるわけではない薄いラッパーであり、パフォーマンスはOSが提供するものとまったく同じです:高速なアトミック、高速なアンコンテンデッドロック、そして粗粒度の作業ではGoの約10%以内のプールされたスループット。しかし、細粒度の、値ごとのハンドオフに切り替えるとすぐに、カーネルウェイクアップのコストが主な要因となり、スローダウンに気づくでしょう。

pthreadアプローチがあなたに適していると思うなら、Solodを試してみてください。これには、Goの標準ライブラリから移植された他の多くのパッケージとともに、syncおよびconcパッケージが含まれています。

★ サブスクライブして新しい投稿をフォローしてください。