dagrt-fusion.py

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)

    if PRINT_RESULTS_TO_STDOUT:
        print("==== Statement Counts ====")
        outf = sys.stdout
    else:
        out_path = "statement-counts.tex"
        outf = open(out_path, "w")

    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)


@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)

    if PRINT_RESULTS_TO_STDOUT:
        print("==== Scalar Assigment % of Total Mem Ops ====")
        outf = sys.stdout
    else:
        out_path = "scalar-assignments-mem-op-percentage.tex"
        outf = open(out_path, "w")

    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)


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)

    if PRINT_RESULTS_TO_STDOUT:
        print("==== Scalar Assigment Inlining Impact ====")
        outf = sys.stdout
    else:
        out_path = "scalar-assignments-mem-op-percentage.tex"
        outf = open(out_path, "w")

    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)

# }}}


def main():
    if 1:
        # 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()