Beispiel #1
0
def main():

    parser = argparse.ArgumentParser()
    parser.add_argument("-p",
                        "--pattern",
                        help="access pattern",
                        choices=["fix", "random"],
                        default="fix")
    parser.add_argument("-r",
                        "--ratio",
                        help="graph ratio",
                        type=float,
                        default=ratio)
    args = parser.parse_args()

    pdffile = "graph/graph_bw2_{}.pdf".format(args.pattern)

    fig, ax = plt.subplots()

    xticks = []
    yaxis = []

    for x in range(1, 129):

        dma_len = x * 16

        xticks.append(dma_len)
        f = ("output/pciebench_bw2_read_ptr-{}_len-{}.txt".format(
            args.pattern, dma_len))
        yaxis.append(parse(f))

    ax.plot(xticks, yaxis, color=get_color())

    plt.yticks([0, 1, 2, 3, 4, 5])
    plt.xticks([16, 512, 1024, 1536, 2048])

    ax.tick_params(labelsize=fontsize)
    ax.set_ylabel("throughput (Gbps)", fontsize=fontsize)
    ax.set_xlabel("request size (byte)", fontsize=fontsize)

    ax.grid(True, linestyle="--", linewidth=0.5)

    change_aspect_ratio(ax, args.ratio)

    print("save '{}'".format(pdffile))
    plt.savefig(pdffile, bbox_inches="tight", pad_inches=0.005)
def main():

    parser = argparse.ArgumentParser()
    parser.add_argument("-p",
                        "--pattern",
                        help="access pattern",
                        choices=["fix", "random"],
                        default="fix")
    args = parser.parse_args()

    pdffile = "graph/graph_lat2_{}.pdf".format(args.pattern)

    fig, ax = plt.subplots()

    yaxis = []
    xticks = []

    for x in range(1, 129):

        dma_len = x * 16
        xticks.append(dma_len)

        f = ("output/pciebench_lat2_" +
             "read_ptr-{}_len-{}.txt".format(args.pattern, dma_len))

        yaxis.append(parse(f))

    ax.plot(xticks, yaxis, color=get_color())

    plt.yticks(list(map(lambda x: x * 5, range(6))))
    plt.xticks([0, 512, 1024, 1536, 2048])

    ax.tick_params(labelsize=fontsize)
    ax.set_ylabel("latency (usec)", fontsize=fontsize)
    ax.set_xlabel("transfer size (byte)", fontsize=fontsize)

    ax.grid(True, linestyle="--", linewidth=0.5)

    change_aspect_ratio(ax, 2)

    print("save '{}'".format(pdffile))
    plt.savefig(pdffile, bbox_inches="tight", pad_inches=0.005)
Beispiel #3
0
def main():

    parser = argparse.ArgumentParser()
    parser.add_argument("-p",
                        "--pattern",
                        help="access pattern",
                        choices=["fix", "random"],
                        default="fix")
    args = parser.parse_args()

    pdffile = "graph/graph_bw_{}.pdf".format(args.pattern)

    fig, ax = plt.subplots()

    dma_lens = [8, 16, 32, 64, 128, 256, 512, 1024, 2048]
    xticks = list(range(9))

    yaxis = []

    for dma_len in dma_lens:
        f = ("output/pciebench_bw_read_ptr-{}_len-{}.txt".format(
            args.pattern, dma_len))
        yaxis.append(parse(f))

    ax.plot(xticks, yaxis, marker=get_marker(), color=get_color())

    print(xticks)
    print(yaxis)

    plt.xticks(xticks, dma_lens)

    ax.tick_params(labelsize=fontsize)
    ax.set_ylabel("throughput (Gbps)", fontsize=fontsize)
    ax.set_xlabel("transfer size (byte)", fontsize=fontsize)

    ax.grid(True, linestyle="--", linewidth=0.5)

    change_aspect_ratio(ax, 2)

    print("save '{}'".format(pdffile))
    plt.savefig(pdffile, bbox_inches="tight", pad_inches=0.005)
Beispiel #4
0
def main():

    parser = argparse.ArgumentParser()
    parser.add_argument("-d",
                        "--direction",
                        help="DMA direction",
                        choices=["read", "write"],
                        default="read")
    parser.add_argument("-l",
                        "--dmalen",
                        help="DMA length to be drawn",
                        action="append")
    parser.add_argument("-p",
                        "--pattern",
                        help="access pattern",
                        choices=["seq", "fix", "random"],
                        default="seq")
    parser.add_argument("-R",
                        "--ratio",
                        help="aspect ratio",
                        type=float,
                        default=1.5)
    parser.add_argument("-o",
                        "--output",
                        help="output pdf file name",
                        default=None)
    args = parser.parse_args()

    if not args.dmalen:
        dma_lens = [1, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
    else:
        dma_lens = args.dmalen
    cpu_nums = [1]

    if not args.output:
        pdffile = ("graph/graph_latency_{}_".format(args.direction) +
                   "pattern-{}.pdf".format(args.pattern))

    else:
        pdffile = args.output

    fig, ax = plt.subplots()

    maximum = 0

    for dma_len in dma_lens:

        for cpu_num in cpu_nums:
            f = ("output-lat/{}_".format(args.direction) +
                 "pattern-{}_".format(args.pattern) +
                 "dmalen-{}_".format(dma_len) + "cpu-{}.txt".format(cpu_num))

        xaxis, yaxis = parse_lat(f)

        ax.plot(xaxis,
                yaxis,
                color=get_color(),
                linestyle=get_linestyle(),
                label="DMA {}B".format(dma_len))

        # save maximum x value
        if maximum < max(xaxis):
            maximum = max(xaxis)

    #xticks = list(range(int(maximum) + 2))
    #plt.xticks(xticks, xticks)
    plt.yticks(list(map(lambda x: x * 0.2, range(0, 6))))

    ax.tick_params(labelsize=fontsize)
    ax.set_ylabel("CDF", fontsize=fontsize)
    ax.set_xlabel("latency (usec)", fontsize=fontsize)

    ax.grid(True, linestyle="--", linewidth=0.5)
    ax.legend(fontsize=lfontsize, loc="lower right")

    change_aspect_ratio(ax, args.ratio)

    print("save '{}'".format(pdffile))
    plt.savefig(pdffile, bbox_inches="tight", pad_inches=0.05)
Beispiel #5
0
def main():

    round_map = {
        "G": 1000000000,
        "M": 1000000,
        "K": 1000,
    }

    parser = argparse.ArgumentParser()
    parser.add_argument("-u",
                        "--unit",
                        help="unit of bandwidth",
                        choices=["bps", "tps"],
                        default="bps")
    parser.add_argument("-d",
                        "--direction",
                        help="DMA direction",
                        choices=["read", "write"],
                        default="read")
    parser.add_argument("-l",
                        "--dmalen",
                        help="DMA length to be drawn",
                        action="append")
    parser.add_argument("-p",
                        "--pattern",
                        help="access pattern",
                        choices=["seq", "fix", "random"],
                        default="seq")
    parser.add_argument("-r",
                        "--round",
                        help="round up x axis",
                        choices=round_map.keys(),
                        default=list(round_map.keys())[0])
    parser.add_argument("-R",
                        "--ratio",
                        help="aspect ratio",
                        type=float,
                        default=1.5)
    parser.add_argument("-o",
                        "--output",
                        help="output pdf file name",
                        default=None)
    args = parser.parse_args()

    if not args.dmalen:
        dma_lens = reversed([1, 4, 8, 16, 32, 64, 128, 256, 512, 1024])
    else:
        dma_lens = args.dmalen
    cpu_nums = [1, 2, 4, 6, 8, 10, 12, 14, 16]

    if not args.output:
        pdffile = ("graph/graph_{}_x-cpu_".format(args.direction) +
                   "pattern-{}_".format(args.pattern) +
                   "{}.pdf".format(args.unit))
    else:
        pdffile = args.output

    fig, ax = plt.subplots()

    maximum = 0

    for dma_len in dma_lens:

        bpses = []
        tpses = []

        for cpu_num in cpu_nums:
            f = ("output/{}_".format(args.direction) +
                 "pattern-{}_".format(args.pattern) +
                 "dmalen-{}_".format(dma_len) + "cpu-{}.txt".format(cpu_num))

            bps, tps = parse(f)
            bpses.append(bps)
            tpses.append(tps)

        if args.unit == "bps":
            yaxis = bpses
        elif args.unit == "tps":
            yaxis = tpses

        # round up to K, M, or G
        yaxis = list(map(lambda x: x / round_map[args.round], yaxis))

        ax.plot(cpu_nums,
                yaxis,
                marker=get_marker(),
                color=get_color(),
                label="DMA {}B".format(dma_len))

        print(f)
        for x in range(len(cpu_nums)):
            print("{}\t{}".format(cpu_nums[x], yaxis[x]))
        print()

        # save maximum y value
        if maximum < max(yaxis):
            maximum = max(yaxis)

    yticks = list(range(int(maximum) + 2))  # this code depends on round up Gig
    plt.yticks(yticks, yticks)
    plt.xticks(cpu_nums, cpu_nums)

    ax.tick_params(labelsize=fontsize)
    ax.set_ylabel("throughput ({}{})".format(args.round, args.unit),
                  fontsize=fontsize)
    ax.set_xlabel("number of cores", fontsize=fontsize)

    ax.grid(True, linestyle="--", linewidth=0.5)
    ax.legend(fontsize=lfontsize)

    change_aspect_ratio(ax, args.ratio)

    print("save '{}'".format(pdffile))
    plt.savefig(pdffile, bbox_inches="tight", pad_inches=0.05)
def main():

    round_map = {
        "G": 1000000000,
        "M": 1000000,
        "K": 1000,
    }

    parser = argparse.ArgumentParser()
    parser.add_argument("-u",
                        "--unit",
                        help="unit of bandwidth",
                        choices=["bps", "tps"],
                        default="bps")
    parser.add_argument("-p",
                        "--pattern",
                        help="access pattern",
                        choices=["seq", "seq512", "fix", "random"],
                        default="seq")
    parser.add_argument("-r",
                        "--round",
                        help="round up x axis",
                        choices=round_map.keys(),
                        default=list(round_map.keys())[0])
    parser.add_argument("-R",
                        "--ratio",
                        help="aspect ratio",
                        type=float,
                        default=ratio)
    parser.add_argument("-o",
                        "--output",
                        help="output pdf file name",
                        default=None)
    args = parser.parse_args()

    dma_lens = list(map(lambda x: x * 16, range(129)))
    dma_lens[0] = 1
    xaxis = list(map(lambda x: x * 512, range(5)))
    xaxis[0] = 1

    if not args.output:
        pdffile = ("graph/graph_x-dmalen-16binterval_" +
                   "pattern-{}_{}.pdf".format(args.pattern, args.unit))
    else:
        pdffile = args.output

    fig, ax = plt.subplots()

    bpses = []
    tpses = []

    for dma_len in dma_lens:
        f = ("output-16b/read_pattern-{}_".format(args.pattern) +
             "dmalen-{}_".format(dma_len) + "cpu-16.txt")

        bps, tps = parse(f)
        bpses.append(bps)
        tpses.append(tps)

    if args.unit == "bps":
        yaxis = bpses
    elif args.unit == "tps":
        yaxis = tpses

    # round up to K, M, or G
    yaxis = list(map(lambda x: x / round_map[args.round], yaxis))

    ax.plot(dma_lens, yaxis, color=get_color())

    plt.yticks([0, 1, 2, 3, 4])
    plt.xticks(xaxis)
    ax.tick_params(labelsize=fontsize)
    ax.set_ylabel("throughput ({}{})".format(args.round, args.unit),
                  fontsize=fontsize)
    ax.set_xlabel("request size (byte)", fontsize=fontsize)

    ax.grid(True, linestyle="--", linewidth=0.5)

    change_aspect_ratio(ax, args.ratio)

    print("save '{}'".format(pdffile))
    plt.savefig(pdffile, bbox_inches="tight", pad_inches=0.05)