ライブネス解析への賛歌；SSAからレジスタへ

ライブネス解析への賛歌；SSAからレジスタへ

愛の歌でしょうか？「歓喜の歌」を聴きながら読んでください。この記事のために描いた素晴らしいピクセルアートもご覧ください。

［画像: livelyness analysis］ それは生命を分析している

現在、私は自身のプログラミング言語purple-gardenのために、バイトコード仮想マシンとx86ジャストインタイムコンパイラの両方でレジスタ割り当てに取り組んでいます。

レジスタ割り当てとは、無限の量の仮想レジスタを、ハードウェアが持つ限られたストレージリソース、具体的には汎用レジスタ（GPR）、浮動小数点レジスタ（FPR）、およびスタックに割り当てることです（例示的な概要についてはCPU Registers x86を参照してください）。この大仕事の最初のステップがライブネス解析です。

ガーデン（園芸）の例

最もシンプルでありながら、やや非自明な例は次のようになります。

GARDEN

1fn f(a:Int n:Int acc:Int) Int {
2    match {
3        n < 1 { a + acc }
4        { f(a n-1 acc*n) }
5    }
6}

これは、Max Bernsteinによる非常に優れた記事「Linear scan register allocation on SSA」から私が「逆アセンブル」した以下のCコードと同等です[1]。この記事では、IRの表示がよく理解できなかったため、C言語に翻訳し、その後自分の言語（purple gardenにはループがないため、これはf(a n 1)で呼び出された場合にのみ同等です🤓）に翻訳しました。

C

1long f(long a, long n) {
2    long acc = 1;
3    while (n >= 1) {
4        acc = acc * n;
5        n = n - 1;
6    }
7    return a + acc;
8}

f(a,n,acc: Int): Intをpurple gardenのパイプラインに渡すと、最適化された即時表現（-Iを使用）が得られます。これは、一部の値がデッド（不要）であり、削除されたことを意味します[2]。

LLVM

 1fn f1(%v0:Int, %v1:Int, %v2:Int) -> Int {
 2        b0(%v0, %v1, %v2):
 3                %v4:Bool = ILt %v1, 1
 4                br %v4, b1(%v0, %v1, %v2), b2(%v0, %v1, %v2)
 5        b1(%v5, %v6, %v7):
 6                %v8:Int = IAdd %v5, %v7
 7                ret %v8
 8        b2(%v9, %v10, %v11):
 9                %v13:Int = ISub %v10, 1
10                %v14:Int = IMul %v11, %v10
11                tail f1(%v9, %v13, %v14)
12}

Purple garden IRの構造と表記法

Purple gardenの即時表現は、静的単一代入（SSA）形式に基づいています。これは、各値/仮想レジスタが一度だけ代入され、すべて不変であることを意味します。これらは%vNと表記され、仮想レジスタまたは値（読者が好きな方）を意味します。

他の多くのSSA IRとは異なり、pgirはphiノードを使用しません。代わりにブロックパラメータと終端記号を採用しました。これはブロックで構成され、各ブロックはパラメータのリスト、終端記号、および命令の本体を持ち、各命令はSSA形式です。すべての値はブロックローカルであり、ブロック間の唯一のデータフローはブロックパラメータとブロック終端記号を介して促進されます。

LLVM

 1; ID N のブロック
 2; |
 3; v
 4  b2(%v0, %v1, %v2):
 5;    ^^^^^^^^^^^^^ パラメータ 0..2
 6
 7;     値 / 仮想レジスタの定義
 8;      |
 9;      |        命令の種類
10;      v        v
11      %v7:Int = ISub %v1, 1 ; <-- 即値
12;         ^           ^ 引数
13;         |
14;         命令結果の型
15
16;     パラメータ付き終端記号
17      tail f1(%v0, %v7, %v8)

Rustの用語で言うと、次のようになります。

RUST

 1pub struct Block<'b, A: Allocator = Global> {
 2    pub id: Id,
 3    pub instructions: Vec<Instr<'b>, A>,
 4    pub params: ParamsId,
 5    pub term: Option<Terminator>,
 6    // [...]
 7}
 8
 9pub enum Instr<'i> {
10    BinImm {
11        op: BinOp,
12        dst: TypeId<'i>,
13        lhs: Id,
14        imm: i32,
15    },
16    // [...]
17    Noop,
18}
19
20pub enum Terminator {
21    Return {
22        value: Option<Id>,
23    },
24    // [...]
25    Tail {
26        func: Id,
27        args: ParamsId,
28    },
29    // [...]
30}

pretty easy right? ( pretty easy right? は原文ママ)

仮想レジスタ / 値とその生存期間

前のIR例を、今度は仮想レジスタの生存期間注釈付きで見てみましょう（CLIが-IIで呼び出された場合）。

LLVM

 1fn f1(%v0:Int, %v1:Int, %v2:Int) -> Int {             %v0 %v1 %v2 %v4 %v5 %v7 %v8 %v9 %v10 %v11 %v13 %v14
 2    b0(%v0, %v1, %v2):                                |   |   | 
 3        %v4:Bool = ILt %v1, 1                         |   |   |   | 
 4        br %v4, b1(%v0, %v1, %v2), b2(%v0, %v1, %v2)  |   |   |   | 
 5    b1(%v5, %v6, %v7):                                                |   | 
 6        %v8:Int = IAdd %v5, %v7                                       |   |   | 
 7        ret %v8                                                               | 
 8    b2(%v9, %v10, %v11):                                                          |   |    | 
 9        %v13:Int = ISub %v10, 1                                                   |   |    |    | 
10        %v14:Int = IMul %v11, %v10                                                |   |    |    |    | 
11        tail f1(%v9, %v13, %v14)                                                  |             |    | 
12}

この表示は、各値の生存期間を視覚的に理解できるようにします。これはlo（開始）とhi（終了）でエンコードされています。以下は非視覚的な理解を可能にするものです。（位置は線形化されています：ブロックパラメータはブロックのベースに、ブロック命令はブロックのベース+1+命令位置に、終端記号はブロックのベース+命令数+1にあります）

短くも甘い実装：

それが終われば、アルゴリズムは単純なものになります。

1. ブロックをウォークする
2. 終端記号を訪問し、すべての仮想レジスタの使用を観察する
3. 命令を逆順に訪問し、すべての仮想レジスタの定義と使用を観察する
4. ブロックのパラメータを訪問し、それぞれを観察する

観測

観測は次のように定義されます。

• タプル (lo,hi) と pos を使用
• hi==0 の場合；hi=pos を設定
• lo=pos

酸化された（Rustの）用語で言うと、次のようになります。

RUST

1/// observer Id := (lo,hi), always updates lo, only fills hi, if previously unset
2fn observe<V: Allocator>(out: &mut Vec<(u32, u32), V>, id: Id, pos: u32) {
3    let idx = id.0 as usize;
4    let e = &mut out[idx];
5    if e.1 == 0 {
6        e.1 = pos;
7    }
8    e.0 = pos;
9}

定義と使用を助けるヘルパー：

命令や終端記号での定義と使用を尋ねます。

これは、Func::def_of が、命令に定義がある場合に仮想レジスタの定義を返すことを意味します。

RUST

 1impl Func<'_> {
 2    #[must_use]
 3    pub fn def_of(instr: &Instr<'_>) -> Option<Id> {
 4        match instr {
 5            Instr::Alloc { dst, .. }
 6            | Instr::Load { dst, .. }
 7            | Instr::AddrOf { dst, .. }
 8            | Instr::Bin { dst, .. }
 9            | Instr::BinImm { dst, .. }
10            | Instr::LoadConst { dst, .. }
11            | Instr::Call { dst, .. }
12            | Instr::Sys { dst, .. }
13            | Instr::Cast { dst, .. }
14            | Instr::Lookup { dst, .. }
15            | Instr::Assert { dst, .. } => Some(dst.id),
16            Instr::Store { .. } | Instr::Noop => None,
17        }
18    }
19}

命令での値の使用ごとにfを呼び出す

これは、命令での値の使用ごとにfを呼び出すことを意味します。

RUST

 1pub fn for_each_use_of_instr(&self, instr: &Instr<'_>, mut f: impl FnMut(Id)) {
 2    match instr {
 3        Instr::Bin { lhs, rhs, .. } => {
 4            f(*lhs);
 5            f(*rhs);
 6        }
 7        Instr::BinImm { lhs, .. } => f(*lhs),
 8        Instr::Call { args, .. } | Instr::Sys { args, .. } => {
 9            for &a in self.params(*args) {
10                f(a);
11            }
12        }
13        Instr::Cast { from, .. } => f(from.id),
14        Instr::Lookup { subject, .. } => f(*subject),
15        Instr::Store { src, base, .. } => {
16            f(*src);
17            f(*base);
18        }
19        Instr::Assert { cond, .. } => f(*cond),
20        Instr::Load { base, .. } | Instr::AddrOf { base, .. } => f(*base),
21        Instr::LoadConst { .. } | Instr::Noop | Instr::Alloc { .. } => {} // Noop, Alloc は使用しない
22    }
23}

終端記号での値の使用ごとにfを呼び出す

これは、終端記号での値の使用ごとにfを呼び出すことを意味します。

RUST

 1pub fn for_each_use_of_term(&self, term: &Terminator, mut f: impl FnMut(Id)) {
 2    match term {
 3        Terminator::Return {
 4            value: Some(id), ..
 5        } => f(*id),
 6        Terminator::Return { value: None, .. } => {} // 値がない場合は何もしない
 7        Terminator::Jump { params, .. } => {
 8            for &p in self.params(*params) {
 9                f(p);
10            }
11        }
12        Terminator::Tail { args, .. } => {
13            for &a in self.params(*args) {
14                f(a);
15            }
16        }
17        Terminator::Switch {
18            subject,
19            cases,
20            default: (_, default_params),
21            ..
22        } => {
23            f(*subject);
24            for case in self.cases(*cases) {
25                for &p in self.params(case.target.1) {
26                    f(p);
27                }
28            }
29            for &p in self.params(*default_params) {
30                f(p);
31            }
32        }
33        Terminator::Branch {
34            cond,
35            yes: (_, yes_params),
36            no: (_, no_params),
37            ..
38        } => {
39            f(*cond);
40            for &p in self.params(*yes_params) {
41                f(p);
42            }
43            for &p in self.params(*no_params) {
44                f(p);
45            }
46        }
47        Terminator::BranchCmpImm {
48            lhs,
49            yes: (_, yes_params),
50            no: (_, no_params),
51            ..
52        }
53        | Terminator::BranchCmp {
54            lhs,
55            yes: (_, yes_params),
56            no: (_, no_params),
57            ..
58        } => {
59            f(*lhs);
60            if let Terminator::BranchCmp { rhs, .. } = term {
61                f(*rhs);
62            }
63            for &p in self.params(*yes_params) {
64                f(p);
65            }
66            for &p in self.params(*no_params) {
67                f(p);
68            }
69        }
70    }
71}

全てをRustで結合：

いくつかの簡単なコンテキストインジェクター：

• outはVアロケータで割り当てられた再利用可能なVecなので、リセットおよびリサイズされます。
• UNSETはデフォルトの空の値として使用されます。
• Func::next_id()は、関数内で定義された最大のID（self）+1を返します。

RUST

 1impl<A: Allocator> Func<'_, A> {
 2    pub fn live_set_into<V: Allocator>(&self, out: &mut Vec<(u32, u32), V>) {
 3        const UNSET: (u32, u32) = (u32::MAX, 0u32);
 4
 5        out.clear();
 6        out.resize(self.next_id() as usize, UNSET);
 7
 8        // observeは前述の通り
 9
10        let mut base = 0;
11        for block in self.blocks.iter().filter(|b| !b.tombstone) {
12            let block_offset = block.instructions.len();
13            let offset = base;
14            if let Some(term) = &block.term {
15                self.for_each_use_of_term(term, |id| {
16                    // termは命令数 +1
17                    observe(out, id, (offset + block_offset + 1) as u32)
18                });
19            }
20
21            for (i, instr) in block.instructions.iter().enumerate().rev() {
22                // +1 なので、パラメータが始まる0から開始できません :)
23                let pos = (base + 1 + i) as u32;
24                self.for_each_use_of_instr(instr, |id| observe(out, id, pos));
25                if let Some(def) = Func::def_of(instr) {
26                    observe(out, def, pos)
27                }
28            }
29
30            for &p in self.params(block.params) {
31                observe(out, p, base as u32);
32            }
33
34            // パラメータ + 命令 + 終端記号
35            base += block_offset + 2;
36        }
37    }
38}

バイトコードバックエンドのためのレジスタ割り当てへのライブセット解析の組み込み

これで、どの値がどこで生きているか、そしていつ死ぬと見なされるかがわかったので、この情報をレジスタアロケータに渡して、ハードウェアまたは仮想マシンの制約に適合させる必要がある任意の値のレジスタまたはスタックスロットを要求できます。

準備とレジスタ割り当てプリパス

purple garden VM用のIRをコンパイルする際、最初のステップはライブセットを計算することです。これは、前述のアルゴリズムを使用し、その後Cc::preallocメソッドでプリ割り当てパスを実行します。

RUST

 1impl<'cc, S: Allocator + Clone, A: Allocator + Clone> Cc<'cc, S, A> {
 2    fn cc<F: Allocator>(
 3        &mut self,
 4        fun: &'cc Func<'cc, F>,
 5        native: Option<&mut purple_garden_jit::CodeArena<impl Pages>>,
 6    ) {
 7        // [...]
 8
 9        // ライブセットを計算
10        fun.live_set_into(&mut self.live_set);
11
12        // 低レベル化の前にIRを一度ウォークします。これ以降は単純な
13        // ルックアップになります。
14        self.prealloc(fun);
15
16        // [...] ブロックをイテレート
17
18            // [...] 命令をイテレート
19
20                // スタックを指すdstを持つ命令の秘密の後処理
21                if let Some(Location::Stack(slot)) =
22                    Func::def_of(instruction).and_then(|dst| self.regalloc.location(dst))
23                {
24                    self.emit(Op::StoreSlot { slot, src: TMP });
25                }
26    }
27}

Bin IRオペレーションの低レベル化

Binはベースラインオペレーションです。私たちの例で見られるBinImmオペレーション（ISub %v10, 1）は最適化です（ディスパッチが1つ少なく、メモリインタラクションが少ない）。これは即値の右辺値で同じようにコンパイルされます。

RUST

 1impl<'cc, S: Allocator + Clone, A: Allocator + Clone> Cc<'cc, S, A> {
 2    fn instr<F: Allocator>(&mut self, owner: &'cc Func<'cc, F>, i: &'cc ir::Instr<'cc>) {
 3        match i {
 4            // [...] 他のすべてのIR命令
 5            ir::Instr::Bin {
 6                op,
 7                dst,
 8                lhs,
 9                rhs,
10                .. 
11            } => {
12                // レジスタ割り当てプリパスとの連携
13                let dst = self.def_register(dst.id);
14                let lhs = self.ensure_register(*lhs);
15                let rhs = self.ensure_register(*rhs);
16
17                macro_rules! emit_bins {
18                    ($($name:ident),*) => {
19                        match op {
20                            $( 
21                                ir::BinOp::$name => {
22                                    Op::$name {
23                                        dst,
24                                        lhs,
25                                        rhs,
26                                    }
27                                },
28                            )*
29                        }
30                    };
31                }
32
33                self.emit(emit_bins! {
34                    IAdd, ISub, IMul, IDiv, IMod, IAnd, ILt, IGt, IEq,
35                    DAdd, DSub, DMul, DDiv, DLt, DGt,
36                    BEq, SEq
37                });
38            }
39            ir::Instr::BinImm {
40                op,
41                dst,
42                lhs,
43                imm,
44                .. 
45            } => {
46                let dst = self.def_register(dst.id);
47                let lhs = self.ensure_register(*lhs);
48                let imm = *imm;
49
50                macro_rules! emit_bin_imms {
51                    ($($ir:ident => $op:ident),* $(,)?) => {
52                        match op {
53                            $(ir::BinOp::$ir => Op::$op { dst, lhs, imm },)*
54                            _ => unreachable!("only integer immediate binops are represented as BinImm"),
55                        }
56                    };
57                }
58
59                self.emit(emit_bin_imms! {
60                    IAdd => IAddI,
61                    ISub => ISubI,
62                    IMul => IMulI,
63                    IDiv => IDivI,
64                    IMod => IModI,
65                    IAnd => IAndI,
66                    IEq  => IEqI,
67                    IGt  => IGtI,
68                    ILt  => ILtI,
69                });
70            }
71        }
72    }
73}

これは非常にクリーンで、Rustのマクロの良い使い方です。大好きです。私に意見を言わないでください。バイナリ演算と即値付きバイナリ演算のすべての操作を57行で低レベル化することが重要です。

レジスタの確保と定義

操作を適用できるポイントまで、要求された仮想レジスタを確実にアクセス可能にするための2つのヘルパー。最初のヘルパーはensure_registerです。

RUST

 1/// 仮想レジスタをVMレジスタに変換します。スピル、リストア、およびレジスタ
 2/// 全般の割り当てを抽象化します。
 3fn ensure_register(&mut self, id: Id) -> u8 {
 4    match self.regalloc.location(id) {
 5        Some(Location::Reg(r)) => return r.num(),
 6        // 要求された値はスタック上にあります。リストアする必要があり、一時的な
 7        // レジスタを使用します。
 8        Some(Location::Stack(slot)) => {
 9            let dst = self.next_tmp();
10            self.emit(Op::LoadSlot { dst, slot });
11            dst
12        }
13        None => unreachable!("%v{} has no location", id.0),
14    }
15}
16
17fn next_tmp(&self) -> u8 {
18    match self.buf.last() {
19        Some(Op::LoadSlot { dst: SCRATCH, .. }) => TMP,
20        _ => SCRATCH,
21    }
22}

これは、値が要求された場合、次のようになります。

• 事前パスでレジスタに割り当てられた場合、それは完璧であり、単純に使用できます。
• またはスタック上にある場合、コンパイラ状態に一時レジスタを要求し、その値をマテリアライズする必要があります。

仮想マシンの一時レジスタは、VMソースコードの先頭でそれぞれSCRATCHとTMPとして定義されています。

RUST

 1pub const REGISTER_COUNT: usize = 32;
 2const SCRATCH: u8 = REGISTER_COUNT as u8 - 1;
 3const TMP: u8 = SCRATCH - 1;
 4
 5/// [`SCRATCH`]と[`TMP`]以外のすべてのVMレジスタ。r0は最後です。なぜなら、xralloc2は
 6/// 最小の空きレジスタを最初に渡すため、呼び出し元保存レジスタが
 7/// 呼び出し先保存レジスタの前に配置されるからです。
 8const POOL: [u8; TMP as usize] = {
 9    let mut pool = [0; TMP as usize];
10    let mut i = 0;
11    while i < TMP as usize {
12        pool[i] = (TMP as usize - 1 - i) as u8;
13        i += 1;
14    }
15    pool
16};

これまでのところ、ensureは理解しやすいです。もう1つのヘルパーはdef_registerです。これは、再びレジスタ番号を取得し、それがない場合はTMPを取得することを意味します。これは、以前に導入された（そしておそらく誰も気づかなかった）準備とレジスタ割り当てプリパスのコードブロックの最後にスニペットされたもので、その後、対応するバイトコード命令でスタック上のスロットに「スピル」します。

RUST

1/// オペレーションが`id`を書き込むレジスタ。`id`がスロットに格納されている場合は[`TMP`]です。ブロックループは
2/// オペレーション後にそこに格納します。
3fn def_register(&self, id: Id) -> u8 {
4    match self.regalloc.location(id) {
5        Some(Location::Reg(r)) => r.num(),
6        Some(Location::Stack(_)) => TMP,
7        None => unreachable!("%v{} has no location", id.0),
8    }
9}

全てのバイトとコードを一緒に：

-Iを-Dに（--no-jitを使用しない場合、マシンコードが得られてしまうため🤓）置き換えると、次の仮想マシンレジスタがSSA値に割り当てられます。

ASM

 100000000 <f>:
 2  0000:    ilt_imm r3, r1, #1        ; 4: n < 1 { a + acc }
 3  0001:    jmpf r3, 0004 <f.bb_0004>
 4  0002:    iadd r0, r0, r2
 5  0003:    ret
 600000004 <f.bb_0004>:
 7  0004:    isub_imm r3, r1, #1       ; 5: { f(a n-1 acc*n) }
 8  0005:    imul r2, r2, r1
 9  0006:    mov r1, r3
10  0007:    tail 0000 <f>

JIT :O

クレイジーなハッカーのために、JITをオンにした場合の同じ例です。JITとBCは、IR、ライブネス解析、レジスタ割り当て、標準ライブラリを共有しています。楽しいでしょう？

ASM

 10000000000000000 <jit_f>:
 2   0:   48 81 fa 01 00 00 00    cmp    $0x1,%rdx
 3   7:   49 c7 c0 00 00 00 00    mov    $0x0,%r8
 4   e:   41 0f 9c c0             setl   %r8b
 5  12:   4d 85 c0                test   %r8,%r8
 6  15:   0f 84 0b 00 00 00       je     26 <jit_f+0x26>
 7  1b:   48 01 ce                add    %rcx,%rsi
 8  1e:   48 89 f0                mov    %rsi,%rax
 9  21:   c3                      ret
10  22:   cc                      int3
11  23:   cc                      int3
12  24:   cc                      int3
13  25:   cc                      int3
14  26:   49 89 d0                mov    %rdx,%r8
15  29:   49 81 e8 01 00 00 00    sub    $0x1,%r8
16  30:   49 89 c9                mov    %rcx,%r9
17  33:   4c 0f af ca             imul   %rdx,%r9
18  37:   4c 89 c2                mov    %r8,%rdx
19  3a:   4c 89 c9                mov    %r9,%rcx
20  3d:   e9 be ff ff ff          jmp    0 <jit_f>
21  42:   c3                      ret

x86出力に意地悪しないでください。もっと短くできることはわかっています。比較とジャンプは単一の命令にでき、無駄なコードや長いエンコーディングがたくさんありますが、これは私の最初のJITであり、動作すること自体に満足しています。

今後の作業

注意深い読者は、レジスタアロケータの入力と出力を、それぞれライブセット（およびレジスタプール）と仮想レジスタから物理レジスタへの割り当てとして、私がどのように説明したかを理解したかもしれませんが、実際にはレジスタアロケータ自体や、IR設計の結果（すべてのブロック遷移（ジャンプ、エントリ、リターン）をエッジ移動として扱い、解決するために追加の作業が必要になるようにする）を示したり紹介したりしていません。

私のモチベーションが続くなら、これらのトピックについてフォローアップ記事を書くつもりですが、今はまだIR、レジスタアロケータ、バックエンド間の相互作用を「完璧にする」プロセス中です。ですから、続報にご期待ください。私が不整合なつぶやきを叫んでいる深淵の果てに実際にいる人がいれば、RSSフィードがあります。

---

1. これは[Z|Y]JITの人物です。信じられないほど素晴らしい記事です。コンパイラ関連に興味がある人は誰でも少なくとも2回は読むべきです↩︎

2. ここでの最適化とは、比較や算術演算のための即値のインライン展開、テールコール、および間接リターンにのみ使用されたブロックの削除を意味します↩︎

---

[2] タイトル: 312の米国都市における駐車アプリの手数料（中央値$0.35/セッション）
URL: https://parkgraph.com/parking-app-fees
本文:

駐車アプリの手数料（都市別）

主要な発見

• 最も一般的な手数料：$0.35（108か所）、$0.45（56か所）、$0.30（30か所）。
• 最も高い固定手数料：アラスカ州アンカレッジで$0.70。
• 15か所ではアプリ手数料は無料です。
• データは43州とコロンビア特別区の312か所をカバーしています。13行には公開されている手数料がありません。

駐車アプリの手数料（アプリ会社別）

手数料が公開されている場所でのセッションあたりの手数料（アプリ会社別）。ソースはページの下部に記載されています。

駐車アプリの手数料（アプリ会社別）

駐車アプリの手数料（場所別）

データ内のすべての場所（州別）。ソース列には、各手数料の出所と、そのページが最後に更新または確認された日時が記載されています。都市名をクリックすると、Park Graphの駐車ページ（存在する場合）にリンクされます。

駐車アプリの手数料（場所別）

公開されていません：ソースページに手数料の記載がない場合。

駐車場所有者向け

このレポートの手数料は、お客様の料金に加えて、ドライバーが支払うものです。Park Graphはオペレーター側でトランザクションごとのソフトウェア手数料を請求し、ドライバーに別途手数料を追加することはありません。ドライバーはサインのQRコードをスキャンし、お客様が設定した料金を、ダウンロード不要のアプリで支払います。各プランの手数料については、Park Graphの料金をご覧ください。または、Park Graphと上記のアプリを比較してください。

• Park Graph vs. ParkMobile
• Park Graph vs. PayByPhone
• Park Graph vs. Passport
• Park Graph vs. Flowbird
• Park Graph vs. HONK
• すべての比較

方法論

Park Graphは、各米国都市でアプリ会社または都市が公開している、駐車セッションを開始するためにドライバーが支払うセッションあたりの手数料を収集しました。対象は、ParkMobile、PayByPhone、Passport、Flowbird、Park Smarter、およびこれらの会社が運営する都市ブランドのアプリです。ソースは、アプリ会社のヘルプページおよび公式の都市ページです。会社ページと都市ページが異なる場合、CSVのfee_notes列にその旨が記載されます。

公開されている手数料がない場所も行として残し、ここでは「公開されていません」と表示しています。アプリ会社が提供する会員プランとその価格は、CSVの会員列に記載されています。すべての行は2026年11月5日に確認されました。

ソース

1. ParkMobileヘルプセンター · 2026年11月現在、289の都市とゾーンの記事がCSVにリンクされています。
2. ツーソン, AZ: tucsonaz.gov · 2026年11月現在
3. ロサンゼルス, CA: ladot.lacity.gov · 2026年11月現在
4. サンディエゴ, CA: sandiego.gov · 2026年11月現在
5. サンフランシスコ, CA: sfmta.com · 2026年11月現在
6. デンバー, CO: denvergov.org · 2026年11月現在
7. ジャクソンビル, FL: jacksonville.gov · 2026年11月現在
8. マイアミ, FL: miamiparking.com · 2026年11月現在
9. シカゴ, IL: parkchicago.com · 2026年11月現在
10. マウントプロスペクト, IL: mountprospect.org · 2026年11月現在
11. ニューオーリンズ, LA: nola.gov · 2026年11月現在
12. ボストン, MA: boston.gov · 2026年11月現在
13. モンゴメリー郡, MD: montgomerycountymd.gov · 2026年11月現在
14. シャーロット, NC: charlottenc.gov · 2026年11月現在
15. ローリー, NC: raleighnc.gov · 2026年11月現在
16. ニューヨーク, NY: portal.311.nyc.gov · 2026年11月現在
17. コロンバス, OH: columbus.gov · 2026年11月現在
18. オクラホマシティ, OK: embarkok.com · 2026年11月現在
19. ポートランド, OR: portland.gov · 2026年11月現在
20. クラークスビル, TN: clarksvilletn.gov · 2026年11月現在
21. ナッシュビル, TN: nashville.gov · 2026年11月現在
22. オースティン, TX: austintexas.gov · 2026年11月現在
23. サンアントニオ, TX: saparkapp.sanantonio.gov · 2026年11月現在
24. クラーク郡, WA: clark.wa.gov · 2026年11月現在
25. シアトル, WA: news.seattle.gov · 2026年11月現在
26. マディソン, WI: cityofmadison.com · 2026年11月現在

データをダウンロード