dagrt-fusion.py

    vol_discr_2d = dg_discr_2d.discr_from_dd("vol")
    dofs_2d = {group.nunit_nodes for group in vol_discr_2d.groups}
    from pytools import one
    print("Number of DOFs per 2D element:", one(dofs_2d), file=outf)

    _, dg_discr_3d = get_strong_wave_op_with_discr(cl_ctx, dims=3, order=order)
    print("Number of 3D elements:", dg_discr_3d.mesh.nelements, file=outf)
    vol_discr_3d = dg_discr_3d.discr_from_dd("vol")
    dofs_3d = {group.nunit_nodes for group in vol_discr_3d.groups}
    from pytools import one
    print("Number of DOFs per 3D element:", one(dofs_3d), file=outf)
    logger.info("Wrote '%s'", outf.name)


def statement_counts_table():
    cl_ctx = cl.create_some_context()
    queue = cl.CommandQueue(cl_ctx)

    fused_stepper = get_example_stepper(queue, use_fusion=True)
    stepper = get_example_stepper(queue, use_fusion=False)

    outf = open_output_file("statement-counts.tex")
    if not PAPER_OUTPUT:
        print("==== Statement Counts ====", file=outf)

    print(
        table(
            "lr",
            ("Operator", "Grudge Node Count"),
            (
                ("Time integration: baseline",
                 r"\num{%d}" % len(stepper.bound_op.eval_code.instructions)),
                ("Right-hand side: baseline",
                 r"\num{%d}" % len(stepper.grudge_bound_op.eval_code.instructions)),
                ("Inlined operator",
                 r"\num{%d}" % len(fused_stepper.bound_op.eval_code.instructions))
            )),
        file=outf)
    logger.info("Wrote '%s'", outf.name)


@memoize(key=lambda queue, dims: dims)
def mem_ops_results(queue, dims):
    fused_stepper = get_example_stepper(
            queue,
            dims=dims,
            use_fusion=True,
            exec_mapper_factory=ExecutionMapperWithMemOpCounting)

    stepper, ic = get_example_stepper(
            queue,
            dims=dims,
            use_fusion=False,
            exec_mapper_factory=ExecutionMapperWithMemOpCounting,
            return_ic=True)

    t_start = 0
    dt = 0.02
    t_end = 0.02

    result = {}

    for (_, _, profile_data) in stepper.run(
            ic, t_start, dt, t_end, return_profile_data=True):
        pass

    result["nonfused_bytes_read"] = profile_data["bytes_read"]
    result["nonfused_bytes_written"] = profile_data["bytes_written"]
    result["nonfused_bytes_total"] = \
            result["nonfused_bytes_read"] \
            + result["nonfused_bytes_written"]

    result["nonfused_bytes_read_by_scalar_assignments"] = \
            profile_data["bytes_read_by_scalar_assignments"]
    result["nonfused_bytes_written_by_scalar_assignments"] = \
            profile_data["bytes_written_by_scalar_assignments"]
    result["nonfused_bytes_total_by_scalar_assignments"] = \
            result["nonfused_bytes_read_by_scalar_assignments"] \
            + result["nonfused_bytes_written_by_scalar_assignments"]

    for (_, _, profile_data) in fused_stepper.run(
            ic, t_start, dt, t_end, return_profile_data=True):
        pass

    result["fused_bytes_read"] = profile_data["bytes_read"]
    result["fused_bytes_written"] = profile_data["bytes_written"]
    result["fused_bytes_total"] = \
            result["fused_bytes_read"] \
            + result["fused_bytes_written"]

    result["fused_bytes_read_by_scalar_assignments"] = \
            profile_data["bytes_read_by_scalar_assignments"]
    result["fused_bytes_written_by_scalar_assignments"] = \
            profile_data["bytes_written_by_scalar_assignments"]
    result["fused_bytes_total_by_scalar_assignments"] = \
            result["fused_bytes_read_by_scalar_assignments"] \
            + result["fused_bytes_written_by_scalar_assignments"]

    return result


def scalar_assignment_percent_of_total_mem_ops_table():
    cl_ctx = cl.create_some_context()
    queue = cl.CommandQueue(cl_ctx)

    result2d = mem_ops_results(queue, 2)
    result3d = mem_ops_results(queue, 3)

    outf = open_output_file("scalar-assignments-mem-op-percentage.tex")
    if not PAPER_OUTPUT:
        print("==== Scalar Assigment % of Total Mem Ops ====", file=outf)

    print(
        table(
            "lr",
            ("Operator",
             r"\parbox{1in}{\centering \% Memory Ops. Due to Scalar Assignments}"),
            (
                ("2D: Baseline",
                 "%.1f" % (
                        100 * result2d["nonfused_bytes_total_by_scalar_assignments"]
                        / result2d["nonfused_bytes_total"])),
                ("2D: Inlined",
                 "%.1f" % (
                        100 * result2d["fused_bytes_total_by_scalar_assignments"]
                        / result2d["fused_bytes_total"])),
                ("3D: Baseline",
                 "%.1f" % (
                        100 * result3d["nonfused_bytes_total_by_scalar_assignments"]
                        / result3d["nonfused_bytes_total"])),
                ("3D: Inlined",
                  "%.1f" % (
                        100 * result3d["fused_bytes_total_by_scalar_assignments"]
                        / result3d["fused_bytes_total"])),
            )),
        file=outf)
    logger.info("Wrote '%s'", outf.name)


def scalar_assignment_effect_of_fusion_mem_ops_table():
    cl_ctx = cl.create_some_context()
    queue = cl.CommandQueue(cl_ctx)

    result2d = mem_ops_results(queue, 2)
    result3d = mem_ops_results(queue, 3)

    outf = open_output_file("scalar-assignments-fusion-impact.tex")
    if not PAPER_OUTPUT:
        print("==== Scalar Assigment Inlining Impact ====", file=outf)

    print(
        table(
            "lrrrr",
            ("Operator",
             r"Bytes Read",
             r"Bytes Written",
             r"Total",
             r"\% of Baseline"),
            (
                ("2D: Baseline",
                 r"\num{%d}" % (
                     result2d["nonfused_bytes_read_by_scalar_assignments"]),
                 r"\num{%d}" % (
                     result2d["nonfused_bytes_written_by_scalar_assignments"]),
                 r"\num{%d}" % (
                     result2d["nonfused_bytes_total_by_scalar_assignments"]),
                 "100"),
                ("2D: Inlined",
                 r"\num{%d}" % (
                     result2d["fused_bytes_read_by_scalar_assignments"]),
                 r"\num{%d}" % (
                     result2d["fused_bytes_written_by_scalar_assignments"]),
                 r"\num{%d}" % (
                     result2d["fused_bytes_total_by_scalar_assignments"]),
                 r"%.1f" % (
                     100 * result2d["fused_bytes_total_by_scalar_assignments"]
                     / result2d["nonfused_bytes_total_by_scalar_assignments"])),
                ("3D: Baseline",
                 r"\num{%d}" % (
                     result3d["nonfused_bytes_read_by_scalar_assignments"]),
                 r"\num{%d}" % (
                     result3d["nonfused_bytes_written_by_scalar_assignments"]),
                 r"\num{%d}" % (
                     result3d["nonfused_bytes_total_by_scalar_assignments"]),
                 "100"),
                ("3D: Inlined",
                 r"\num{%d}" % (
                     result3d["fused_bytes_read_by_scalar_assignments"]),
                 r"\num{%d}" % (
                     result3d["fused_bytes_written_by_scalar_assignments"]),
                 r"\num{%d}" % (
                     result3d["fused_bytes_total_by_scalar_assignments"]),
                 r"%.1f" % (
                     100 * result3d["fused_bytes_total_by_scalar_assignments"]
                     / result3d["nonfused_bytes_total_by_scalar_assignments"])),
            )),
        file=outf)
    logger.info("Wrote '%s'", outf.name)

# }}}


def main():
    if not SKIP_TESTS:
        # Run tests.
        from py.test import main
        result = main([__file__])
        assert result == 0

    # Run examples.
    problem_stats()
    statement_counts_table()
    scalar_assignment_percent_of_total_mem_ops_table()
    scalar_assignment_effect_of_fusion_mem_ops_table()


if __name__ == "__main__":
    main()