wgpu/tests/out/collatz.ron

(
    types: [
        (
            name: None,
            inner: Scalar(
                kind: Uint,
                width: 4,
            ),
        ),
        (
            name: None,
            inner: Array(
                base: 1,
                size: Dynamic,
                stride: 4,
            ),
        ),
        (
            name: Some("PrimeIndices"),
            inner: Struct(
                level: Root,
                members: [
                    (
                        name: Some("data"),
                        ty: 2,
                        binding: None,
                        offset: 0,
                    ),
                ],
                span: 4,
            ),
        ),
        (
            name: None,
            inner: Vector(
                size: Tri,
                kind: Uint,
                width: 4,
            ),
        ),
    ],
    constants: [
        (
            name: None,
            specialization: None,
            inner: Scalar(
                width: 4,
                value: Uint(0),
            ),
        ),
        (
            name: None,
            specialization: None,
            inner: Scalar(
                width: 4,
                value: Uint(1),
            ),
        ),
        (
            name: None,
            specialization: None,
            inner: Scalar(
                width: 4,
                value: Uint(2),
            ),
        ),
        (
            name: None,
            specialization: None,
            inner: Scalar(
                width: 4,
                value: Uint(3),
            ),
        ),
    ],
    global_variables: [
        (
            name: Some("v_indices"),
            class: Storage,
            binding: Some((
                group: 0,
                binding: 0,
            )),
            ty: 3,
            init: None,
            storage_access: (
                bits: 3,
            ),
        ),
    ],
    functions: [
        (
            name: Some("collatz_iterations"),
            arguments: [
                (
                    name: Some("n_base"),
                    ty: 1,
                    binding: None,
                ),
            ],
            result: Some((
                ty: 1,
                binding: None,
            )),
            local_variables: [
                (
                    name: Some("n"),
                    ty: 1,
                    init: None,
                ),
                (
                    name: Some("i"),
                    ty: 1,
                    init: Some(1),
                ),
            ],
            expressions: [
                GlobalVariable(1),
                FunctionArgument(0),
                LocalVariable(1),
                Constant(1),
                LocalVariable(2),
                Load(
                    pointer: 3,
                ),
                Constant(2),
                Binary(
                    op: LessEqual,
                    left: 6,
                    right: 7,
                ),
                Load(
                    pointer: 3,
                ),
                Constant(3),
                Binary(
                    op: Modulo,
                    left: 9,
                    right: 10,
                ),
                Constant(1),
                Binary(
                    op: Equal,
                    left: 11,
                    right: 12,
                ),
                Load(
                    pointer: 3,
                ),
                Constant(3),
                Binary(
                    op: Divide,
                    left: 14,
                    right: 15,
                ),
                Constant(4),
                Load(
                    pointer: 3,
                ),
                Binary(
                    op: Multiply,
                    left: 17,
                    right: 18,
                ),
                Constant(2),
                Binary(
                    op: Add,
                    left: 19,
                    right: 20,
                ),
                Load(
                    pointer: 5,
                ),
                Constant(2),
                Binary(
                    op: Add,
                    left: 22,
                    right: 23,
                ),
                Load(
                    pointer: 5,
                ),
            ],
            body: [
                Store(
                    pointer: 3,
                    value: 2,
                ),
                Loop(
                    body: [
                        Emit((
                            start: 5,
                            end: 6,
                        )),
                        Emit((
                            start: 7,
                            end: 8,
                        )),
                        If(
                            condition: 8,
                            accept: [
                                Break,
                            ],
                            reject: [],
                        ),
                        Emit((
                            start: 8,
                            end: 9,
                        )),
                        Emit((
                            start: 10,
                            end: 11,
                        )),
                        Emit((
                            start: 12,
                            end: 13,
                        )),
                        If(
                            condition: 13,
                            accept: [
                                Emit((
                                    start: 13,
                                    end: 14,
                                )),
                                Emit((
                                    start: 15,
                                    end: 16,
                                )),
                                Store(
                                    pointer: 3,
                                    value: 16,
                                ),
                            ],
                            reject: [
                                Emit((
                                    start: 17,
                                    end: 19,
                                )),
                                Emit((
                                    start: 20,
                                    end: 21,
                                )),
                                Store(
                                    pointer: 3,
                                    value: 21,
                                ),
                            ],
                        ),
                        Emit((
                            start: 21,
                            end: 22,
                        )),
                        Emit((
                            start: 23,
                            end: 24,
                        )),
                        Store(
                            pointer: 5,
                            value: 24,
                        ),
                    ],
                    continuing: [],
                ),
                Emit((
                    start: 24,
                    end: 25,
                )),
                Return(
                    value: Some(25),
                ),
            ],
        ),
    ],
    entry_points: [
        (
            name: "main",
            stage: Compute,
            early_depth_test: None,
            workgroup_size: (1, 1, 1),
            function: (
                name: Some("main"),
                arguments: [
                    (
                        name: Some("global_id"),
                        ty: 4,
                        binding: Some(BuiltIn(GlobalInvocationId)),
                    ),
                ],
                result: None,
                local_variables: [],
                expressions: [
                    GlobalVariable(1),
                    FunctionArgument(0),
                    AccessIndex(
                        base: 1,
                        index: 0,
                    ),
                    AccessIndex(
                        base: 2,
                        index: 0,
                    ),
                    Access(
                        base: 3,
                        index: 4,
                    ),
                    AccessIndex(
                        base: 1,
                        index: 0,
                    ),
                    AccessIndex(
                        base: 2,
                        index: 0,
                    ),
                    Access(
                        base: 6,
                        index: 7,
                    ),
                    Load(
                        pointer: 8,
                    ),
                    Call(1),
                ],
                body: [
                    Emit((
                        start: 2,
                        end: 9,
                    )),
                    Call(
                        function: 1,
                        arguments: [
                            9,
                        ],
                        result: Some(10),
                    ),
                    Store(
                        pointer: 5,
                        value: 10,
                    ),
                    Return(
                        value: None,
                    ),
                ],
            ),
        ),
    ],
)