# アーキテクチャ構成図

## 全体アーキテクチャ構成図

```mermaid
graph TB
    subgraph "パブリックAPI層"
        API["include/uv.h<br/>パブリックAPI<br/>（ハンドル型・リクエスト型・コールバック型）"]
        API_PLAT_UNIX["include/uv/unix.h<br/>Unix固有構造体定義"]
        API_PLAT_WIN["include/uv/win.h<br/>Windows固有構造体定義"]
        API_ERRNO["include/uv/errno.h<br/>エラーコード定義"]
        API_VER["include/uv/version.h<br/>バージョン定義"]
    end

    subgraph "共通実装層（Cross-platform）"
        COMMON["src/uv-common.c / uv-common.h<br/>メモリ管理、エラー処理、<br/>ハンドルマクロ"]
        TIMER["src/timer.c<br/>タイマー管理"]
        THREADPOOL["src/threadpool.c<br/>スレッドプール"]
        HEAP["src/heap-inl.h<br/>二分最小ヒープ"]
        QUEUE["src/queue.h<br/>侵入型双方向リスト"]
        FSPOLL["src/fs-poll.c<br/>FSポーリング"]
        RANDOM["src/random.c<br/>乱数生成"]
        INET["src/inet.c<br/>IPアドレス変換"]
        IDNA["src/idna.c<br/>IDNA処理"]
        THREAD_COMMON["src/thread-common.c<br/>スレッド共通処理"]
    end

    subgraph "プラットフォーム固有実装層"
        subgraph "Unix系実装 (src/unix/)"
            UNIX_CORE["core.c / loop.c<br/>イベントループ"]
            UNIX_STREAM["stream.c<br/>ストリーム抽象化"]
            UNIX_TCP["tcp.c"]
            UNIX_UDP["udp.c"]
            UNIX_PIPE["pipe.c"]
            UNIX_FS["fs.c<br/>ファイルシステム"]
            UNIX_PROCESS["process.c<br/>プロセス管理"]
            UNIX_SIGNAL["signal.c<br/>シグナル処理"]
            UNIX_ASYNC["async.c<br/>非同期通知"]
            UNIX_THREAD["thread.c<br/>スレッド"]
        end

        subgraph "Windows実装 (src/win/)"
            WIN_CORE["core.c<br/>イベントループ"]
            WIN_STREAM["stream.c<br/>ストリーム"]
            WIN_TCP["tcp.c"]
            WIN_UDP["udp.c"]
            WIN_PIPE["pipe.c"]
            WIN_FS["fs.c<br/>ファイルシステム"]
            WIN_PROCESS["process.c<br/>プロセス管理"]
            WIN_SIGNAL["signal.c<br/>シグナル処理"]
            WIN_ASYNC["async.c<br/>非同期通知"]
            WIN_THREAD["thread.c<br/>スレッド"]
        end
    end

    subgraph "OSカーネル / システム層"
        EPOLL["epoll<br/>(Linux)"]
        KQUEUE["kqueue<br/>(macOS/BSD)"]
        IOCP["IOCP<br/>(Windows)"]
        IOURING["io_uring<br/>(Linux 5.1+)"]
        EVPORTS["event ports<br/>(SunOS)"]
    end

    API --> COMMON
    API --> API_PLAT_UNIX
    API --> API_PLAT_WIN
    API --> API_ERRNO
    API --> API_VER

    COMMON --> UNIX_CORE
    COMMON --> WIN_CORE
    TIMER --> HEAP
    THREADPOOL --> QUEUE

    UNIX_CORE --> EPOLL
    UNIX_CORE --> KQUEUE
    UNIX_CORE --> EVPORTS
    UNIX_CORE --> IOURING
    WIN_CORE --> IOCP

    UNIX_STREAM --> UNIX_TCP
    UNIX_STREAM --> UNIX_PIPE
```

## イベントループ処理フロー図

```mermaid
flowchart TD
    START["uv_run() 開始"] --> ALIVE{"ループ存続判定<br/>uv__loop_alive()"}
    ALIVE -- "アクティブなし" --> EXIT["return 0"]
    ALIVE -- "アクティブあり" --> UPDATE_TIME["時刻更新<br/>uv__update_time()"]
    UPDATE_TIME --> RUN_TIMERS_INIT["タイマー実行<br/>uv__run_timers()"]
    RUN_TIMERS_INIT --> LOOP_START["ループ反復開始"]

    LOOP_START --> PENDING["保留中コールバック実行<br/>uv__run_pending()"]
    PENDING --> IDLE["idle ハンドル実行<br/>uv__run_idle()"]
    IDLE --> PREPARE["prepare ハンドル実行<br/>uv__run_prepare()"]
    PREPARE --> CALC_TIMEOUT["タイムアウト計算<br/>uv__backend_timeout()"]
    CALC_TIMEOUT --> IO_POLL["I/Oポーリング<br/>uv__io_poll()"]
    IO_POLL --> PENDING2["保留中コールバック実行<br/>(最大8回, 飢餓防止)"]
    PENDING2 --> METRICS["アイドル時間更新<br/>uv__metrics_update_idle_time()"]
    METRICS --> CHECK["check ハンドル実行<br/>uv__run_check()"]
    CHECK --> CLOSING["クローズ処理<br/>uv__run_closing_handles()"]
    CLOSING --> UPDATE_TIME2["時刻再更新<br/>uv__update_time()"]
    UPDATE_TIME2 --> RUN_TIMERS["タイマー再実行<br/>uv__run_timers()"]
    RUN_TIMERS --> ALIVE2{"ループ存続判定"}

    ALIVE2 -- "UV_RUN_DEFAULT<br/>かつアクティブ" --> LOOP_START
    ALIVE2 -- "UV_RUN_ONCE/NOWAIT<br/>または非アクティブ" --> RETURN["return r"]
```

## スレッドプール処理フロー図

```mermaid
sequenceDiagram
    participant App as アプリケーション
    participant Loop as イベントループ<br/>(メインスレッド)
    participant Pool as スレッドプール<br/>(ワーカースレッド)
    participant OS as OS カーネル

    App->>Loop: uv_fs_read(loop, req, cb)
    Loop->>Pool: uv__work_submit(work, UV__WORK_SLOW_IO)
    Note over Pool: mutex ロック<br/>ワークキューに投入<br/>cond_signal で通知

    Pool->>OS: ブロッキング read()
    OS-->>Pool: 結果返却

    Pool->>Loop: loop->wq に完了タスク投入<br/>uv_async_send() で通知
    Note over Loop: 次回 I/Oポーリングで<br/>async通知を検出

    Loop->>Loop: uv__work_done()<br/>完了コールバック実行
    Loop->>App: cb(req, result)
```

## ハンドル継承階層図

```mermaid
classDiagram
    class uv_handle_t {
        +void* data
        +uv_loop_t* loop
        +uv_handle_type type
        +uv_close_cb close_cb
    }

    class uv_stream_t {
        +size_t write_queue_size
        +uv_alloc_cb alloc_cb
        +uv_read_cb read_cb
    }

    class uv_tcp_t {
        +uv_tcp_init()
        +uv_tcp_bind()
        +uv_tcp_connect()
        +uv_listen()
    }

    class uv_pipe_t {
        +int ipc
        +uv_pipe_init()
        +uv_pipe_bind()
        +uv_pipe_connect()
    }

    class uv_tty_t {
        +uv_tty_init()
        +uv_tty_set_mode()
        +uv_tty_get_winsize()
    }

    class uv_udp_t {
        +size_t send_queue_size
        +uv_udp_init()
        +uv_udp_bind()
        +uv_udp_send()
    }

    class uv_timer_t {
        +uv_timer_cb timer_cb
        +uint64_t timeout
        +uint64_t repeat
    }

    class uv_async_t {
        +uv_async_cb async_cb
    }

    class uv_poll_t {
        +uv_poll_cb poll_cb
    }

    class uv_signal_t {
        +uv_signal_cb signal_cb
        +int signum
    }

    class uv_process_t {
        +uv_exit_cb exit_cb
        +int pid
    }

    class uv_fs_event_t {
        +uv_fs_event_cb cb
    }

    class uv_fs_poll_t {
        +uv_fs_poll_cb poll_cb
    }

    class uv_idle_t {
        +uv_idle_cb idle_cb
    }

    class uv_prepare_t {
        +uv_prepare_cb prepare_cb
    }

    class uv_check_t {
        +uv_check_cb check_cb
    }

    uv_handle_t <|-- uv_stream_t
    uv_handle_t <|-- uv_udp_t
    uv_handle_t <|-- uv_timer_t
    uv_handle_t <|-- uv_async_t
    uv_handle_t <|-- uv_poll_t
    uv_handle_t <|-- uv_signal_t
    uv_handle_t <|-- uv_process_t
    uv_handle_t <|-- uv_fs_event_t
    uv_handle_t <|-- uv_fs_poll_t
    uv_handle_t <|-- uv_idle_t
    uv_handle_t <|-- uv_prepare_t
    uv_handle_t <|-- uv_check_t

    uv_stream_t <|-- uv_tcp_t
    uv_stream_t <|-- uv_pipe_t
    uv_stream_t <|-- uv_tty_t
```

## プラットフォーム別I/Oバックエンド対応図

```mermaid
graph LR
    subgraph "I/O多重化バックエンド"
        EPOLL["epoll"]
        KQUEUE["kqueue"]
        IOCP["IOCP"]
        EVPORTS["event ports"]
        POLL["poll"]
        IOURING["io_uring"]
    end

    subgraph "対応プラットフォーム"
        LINUX["Linux"]
        MACOS["macOS"]
        FREEBSD["FreeBSD"]
        NETBSD["NetBSD"]
        OPENBSD["OpenBSD"]
        DRAGONFLY["DragonFly BSD"]
        WINDOWS["Windows"]
        SUNOS["SunOS / Solaris"]
        AIX["AIX"]
        HAIKU["Haiku"]
        QNX["QNX"]
        HURD["GNU/Hurd"]
    end

    LINUX --> EPOLL
    LINUX --> IOURING
    MACOS --> KQUEUE
    FREEBSD --> KQUEUE
    NETBSD --> KQUEUE
    OPENBSD --> KQUEUE
    DRAGONFLY --> KQUEUE
    WINDOWS --> IOCP
    SUNOS --> EVPORTS
    AIX --> POLL
    HAIKU --> POLL
    QNX --> POLL
    HURD --> POLL
```
