Esempi in Python per get_result_path

Esempio n. 1

File: benchmark_copy_compdecomp.py Progetto: zimokernel/HashDAG

    ("VERBOSE_EDIT_TIMES", "0"),
    ("TRACK_GLOBAL_NEWDELETE", "0"),  # XXX
    ("THREADED_EDITS", "1"),
    ("NUM_THREADS", "6"),
    ("TRACY_ENABLE", "0"),
    #("ENABLE_CHECKS", "1"), # XXX XXX XXX XXX XXX
]

# At level 17, we need a bit more space in the buckets.
# This mainly increases the memory consumption of the page size
if scene_depth >= 17:
    #base_defines += [ ("BUCKETS_SIZE_FOR_LOW_LEVELS", (2*2048)) ];
    #base_defines += [ ("BUCKETS_SIZE_FOR_TOP_LEVELS", (2048)) ];
    pass

path = get_result_path("copy_compdecomp")

normal6 = base_defines + [
    ("COPY_WITHOUT_DECOMPRESSION", "0"),
    ("COPY_EMPTY_CHECKS", "0"),
]
run(normal6, "scene={}_depth={}_t6_normal".format(scene, scene_depth), path)

comp6 = base_defines + [
    ("COPY_WITHOUT_DECOMPRESSION", "1"),
    ("COPY_EMPTY_CHECKS", "0"),
]
run(comp6, "scene={}_depth={}_t6_comp".format(scene, scene_depth), path)

comp6e = base_defines + [
    ("COPY_WITHOUT_DECOMPRESSION", "1"),

Esempio n. 2

File: benchmark_copy_compdecomp_sm_voxels.py Progetto: zimokernel/HashDAG

assert len(sys.argv) == 3, "Usage: python script.py scene_name scene_depth"

scene = sys.argv[1]
scene_depth = int(sys.argv[2])
replay_name = "tree_copy2"

base_defines = [
    ("SCENE", "\"{}\"".format(scene)),
    ("SCENE_DEPTH", "{}".format(scene_depth)),
    ("REPLAY_NAME", "\"{}\"".format(replay_name)),
    ("USE_BLOOM_FILTER", "0"),
    ("EDITS_COUNTERS", "1"),
    ("COUNT_COPIED_VOXELS", "1"),
    ("THREADED_EDITS", "1"),
    ("NUM_THREADS", 6),
    ("USE_VIDEO", "0"),
    ("COPY_APPLY_TRANSFORM", "0"),
    ("COPY_CAN_APPLY_SWIRL", "0"),
    ("VERBOSE_EDIT_TIMES", "0"),
    ("TRACK_GLOBAL_NEWDELETE", "0"), # XXX
    ("TRACY_ENABLE", "0"),
    ("COPY_WITHOUT_DECOMPRESSION", "0"),
    ("COPY_EMPTY_CHECKS", "0"),
]

path = get_result_path("copy_edit_voxels_sm")

run(base_defines, "scene={}_depth={}".format(scene, scene_depth), path)

#EOF

Esempio n. 3

File: benchmark_small_edits_nocolor.py Progetto: zimokernel/HashDAG

assert len(sys.argv) == 3, "Usage: python script.py scene_name scene_depth"

scene = sys.argv[1]
scene_depth = int(sys.argv[2])
replay_name = "small_edits"

num_threads = ["2", "4", "6"]
base_defines = [
    ("SCENE", "\"{}\"".format(scene)),
    ("SCENE_DEPTH", "{}".format(scene_depth)),
    ("REPLAY_NAME", "\"{}\"".format(replay_name)),
    ("USE_BLOOM_FILTER", "0"),
    ("EDITS_ENABLE_COLORS", "0"),
    ("EDITS_COUNTERS", "1"),
]

path = get_result_path("edits")

unthreaded = base_defines + [("THREADED_EDITS", "0")]
run(unthreaded, "scene={}_depth={}_nothread".format(scene, scene_depth), path)

for i in range(len(num_threads)):
    nt = num_threads[i]
    threaded = base_defines + [("THREADED_EDITS", "1"),
                               ("NUM_THREADS", num_threads[i])]
    run(
        threaded, "scene={}_depth={}_thread{}".format(scene, scene_depth,
                                                      num_threads[i]), path)
pass

Esempio n. 4

import sys

from benchmark_paths import get_result_path
from benchmark_tools import run

assert len(sys.argv) == 3, "Usage: python script.py scene_name scene_depth"

scene = sys.argv[1]
scene_depth = int(sys.argv[2])
replay_name = "move"

base_defines = [
    ("REPLAY_TWICE", "1"),
    ("ENABLE_SHADOWS", "0"),
    ("SCENE", "\"{}\"".format(scene)),
    ("SCENE_DEPTH", "{}".format(scene_depth)),
    ("REPLAY_NAME", "\"{}\"".format(replay_name)),
]

path = get_result_path("rt")

run(base_defines + [("USE_NORMAL_DAG", "1")],
    "scene={}_depth={}_normal_dag".format(scene, scene_depth), path)
run(base_defines + [("USE_NORMAL_DAG", "0")],
    "scene={}_depth={}_hash_dag".format(scene, scene_depth), path)

Esempio n. 5

File: benchmark_memory_overhead_pagesize.py Progetto: zimokernel/HashDAG

import sys

from benchmark_paths import get_result_path
from benchmark_tools import run

assert len(sys.argv) == 3, "Usage: python script.py scene_name scene_depth"

scene = sys.argv[1]
scene_depth = int(sys.argv[2])
replay_name = "singleframe"

page_sizes = [1024, 128, 256, 512]

base_defines = [
    ("SCENE", "\"{}\"".format(scene)),
    ("SCENE_DEPTH", "{}".format(scene_depth)),
    ("REPLAY_NAME", "\"{}\"".format(replay_name)),
    ("ENABLE_CHECKS",
     "1"),  # nice to have and no impact as we are looking at the memory usage
    ("BUCKETS_BITS_FOR_LOW_LEVELS", "16")
]

path = get_result_path("page_size_memory_overhead")

for i in range(len(page_sizes)):
    ps = page_sizes[i]
    threaded = base_defines + [("PAGE_SIZE", ps)]
    run(threaded,
        "scene={}_depth={}_pagesize={}".format(scene, scene_depth, ps), path)

Esempio n. 6

File: benchmark_bucket_count.py Progetto: zimokernel/HashDAG

    bucket_bits = [18, 17, 16]
    bucket_sizes = [1024 + 512, 2048, 2048 + 1024]

threads = "1"

num_threads = "6"
base_defines = [
    ("SCENE", "\"{}\"".format(scene)),
    ("SCENE_DEPTH", "{}".format(scene_depth)),
    ("REPLAY_NAME", "\"{}\"".format(replay_name)),
    ("USE_BLOOM_FILTER", "0"),
    ("EDITS_COUNTERS", "1"),
    ("THREADED_EDITS", threads),
    ("NUM_THREADS", num_threads),
    ("EDITS_ENABLE_COLORS", "0"),
    ("PAGE_SIZE", "128"),
    #("BUCKETS_BITS_FOR_TOP_LEVELS", "9")
]

path = get_result_path("bucket_count")

for i in range(len(bucket_bits)):
    bb = bucket_bits[i]
    bs = bucket_sizes[i]
    threaded = base_defines + [("BUCKETS_BITS_FOR_LOW_LEVELS", bb),
                               ("BUCKETS_SIZE_FOR_LOW_LEVELS", bs)]
    run(threaded,
        "scene={}_depth={}_bbits{}_bsize{}".format(scene, scene_depth, bb,
                                                   bs), path)
pass

Esempio n. 7

File: benchmark_page_size.py Progetto: zimokernel/HashDAG

threads = "1"
#"0"; # "1"

num_threads = "6"
base_defines = [
    ("SCENE", "\"{}\"".format(scene)),
    ("SCENE_DEPTH", "{}".format(scene_depth)),
    ("REPLAY_NAME", "\"{}\"".format(replay_name)),
    ("USE_BLOOM_FILTER", "0"),
    ("EDITS_COUNTERS", "1"),
    ("THREADED_EDITS", threads),
    ("NUM_THREADS", num_threads),
    ("EDITS_ENABLE_COLORS", "0"),
]

# At level 17, we need a bit more space in the buckets.
# This mainly increases the memory consumption of the page size
if scene_depth >= 17:
    base_defines += [("BUCKETS_SIZE_FOR_LOW_LEVELS", 2048 + 1024)]

path = get_result_path("page_size")

for i in range(len(page_sizes)):
    ps = page_sizes[i]
    threaded = base_defines + [
        ("PAGE_SIZE", ps),
    ]
    run(threaded, "scene={}_depth={}_ps{}".format(scene, scene_depth, ps),
        path)
pass

Esempio n. 8

File: benchmark_copy_compdecomp_sm.py Progetto: zimokernel/HashDAG

    ("COPY_APPLY_TRANSFORM", "0"),
    ("COPY_CAN_APPLY_SWIRL", "0"),
    ("VERBOSE_EDIT_TIMES", "0"),
    ("TRACK_GLOBAL_NEWDELETE", "0"),  # XXX
    ("TRACY_ENABLE", "0"),
    #("ENABLE_CHECKS", "1"), # XXX XXX XXX XXX XXX
]

# At level 17, we need a bit more space in the buckets.
# This mainly increases the memory consumption of the page size
if scene_depth >= 17:
    #base_defines += [ ("BUCKETS_SIZE_FOR_LOW_LEVELS", (2*2048)) ];
    #base_defines += [ ("BUCKETS_SIZE_FOR_TOP_LEVELS", (2048)) ];
    pass
if True:
    path = get_result_path("copy_compdecomp_sm6")

    normal6 = base_defines + [
        ("COPY_WITHOUT_DECOMPRESSION", "0"),
        ("COPY_EMPTY_CHECKS", "0"),
        ("THREADED_EDITS", "1"),
        ("NUM_THREADS", "6"),
    ]
    run(normal6, "scene={}_depth={}_t6_normal".format(scene, scene_depth),
        path)

    comp6 = base_defines + [
        ("COPY_WITHOUT_DECOMPRESSION", "1"),
        ("COPY_EMPTY_CHECKS", "0"),
        ("THREADED_EDITS", "1"),
        ("NUM_THREADS", "6"),

Esempio n. 9

File: benchmark_count_teaser_voxels.py Progetto: zimokernel/HashDAG

import sys

from benchmark_paths import get_result_path
from benchmark_tools import run

assert len(sys.argv) == 3, "Usage: python script.py scene_name scene_depth"

scene = sys.argv[1]
scene_depth = int(sys.argv[2])
replay_names = ["teaser_statue", "teaser_church"]

base_defines = [("SCENE", "\"{}\"".format(scene)),
                ("SCENE_DEPTH", "{}".format(scene_depth)),
                ("USE_BLOOM_FILTER", "0"), ("EDITS_COUNTERS", "1"),
                ("COUNT_COPIED_VOXELS", "1"), ("THREADED_EDITS", "1"),
                ("REPLAY_DEPTH", "17"), ("NUM_THREADS", 6)]

if scene_depth >= 17:
    base_defines += [("BUCKETS_SIZE_FOR_LOW_LEVELS", (2048 + 1024))]

path = get_result_path("teaser_voxels")

for i in range(len(replay_names)):
    name = replay_names[i]
    defs = base_defines + [("REPLAY_NAME", "\"{}\"".format(name))]
    run(defs, "scene={}_depth={}_{}".format(scene, scene_depth, name), path)
pass

#EOF

Esempio n. 10

File: benchmark_copy_edits.py Progetto: zimokernel/HashDAG

num_threads = ["2", "4", "6"]
base_defines = [
    ("SCENE", "\"{}\"".format(scene)),
    ("SCENE_DEPTH", "{}".format(scene_depth)),
    ("REPLAY_NAME", "\"{}\"".format(replay_name)),
    ("USE_BLOOM_FILTER", "0"),
    ("EDITS_COUNTERS", "1"),
    ("USE_VIDEO", "0"),
    ("COPY_APPLY_TRANSFORM", "0"),
    ("COPY_CAN_APPLY_SWIRL", "0"),
    ("VERBOSE_EDIT_TIMES", "0"),
    ("COPY_WITHOUT_DECOMPRESSION", "0"),
    #("COPY_EMPTY_CHECKS", "1"), # XXX
    ("TRACK_GLOBAL_NEWDELETE", "0"),  # XXX
    ("TRACY_ENABLE", "0"),
]

path = get_result_path("copy_edits")

unthreaded = base_defines + [("THREADED_EDITS", "0")]
run(unthreaded, "scene={}_depth={}_nothread".format(scene, scene_depth), path)

for i in range(len(num_threads)):
    nt = num_threads[i]
    threaded = base_defines + [("THREADED_EDITS", "1"),
                               ("NUM_THREADS", num_threads[i])]
    run(
        threaded, "scene={}_depth={}_thread{}".format(scene, scene_depth,
                                                      num_threads[i]), path)

Esempio n. 11

bucket_bits = [20, 19, 18, 17, 16]
bucket_sizes = [256, 1024, 1024, 2048, 2048]

# At level 17, we need a bit more space in the buckets.
# This mainly increases the memory consumption of the page size
#
# Note:
if scene_depth >= 17:
    bucket_bits = [18, 17, 16]
    bucket_sizes = [1024 + 512, 2048, 2048 + 1024]

base_defines = [
    ("SCENE", "\"{}\"".format(scene)),
    ("SCENE_DEPTH", "{}".format(scene_depth)),
    ("REPLAY_NAME", "\"{}\"".format(replay_name)),
    ("ENABLE_CHECKS",
     "1"),  # nice to have and no impact as we are looking at the memory usage
    ("PAGE_SIZE", "128"),
    #("BUCKETS_BITS_FOR_TOP_LEVELS", "9")
]

path = get_result_path("bucket_count_memory_overhead")

for i in range(len(bucket_bits)):
    bb = bucket_bits[i]
    bs = bucket_sizes[i]
    threaded = base_defines + [("BUCKETS_BITS_FOR_LOW_LEVELS", bb),
                               ("BUCKETS_SIZE_FOR_LOW_LEVELS", bs)]
    run(threaded,
        "scene={}_depth={}_bbits{}_bsize{}".format(scene, scene_depth, bb,
                                                   bs), path)

Esempio n. 12

File: benchmark_color_memory.py Progetto: zimokernel/HashDAG

import sys

from benchmark_paths import get_result_path
from benchmark_tools import run

assert len(sys.argv) == 3, "Usage: python script.py scene_name scene_depth"

scene = sys.argv[1]
scene_depth = int(sys.argv[2])
replay_name = "edits"

base_defines = [
    ("SCENE", "\"{}\"".format(scene)),
    ("SCENE_DEPTH", "{}".format(scene_depth)),
    ("REPLAY_NAME", "\"{}\"".format(replay_name)),
    ("EDITS_COUNTERS", "1"),
    ("UNDO_REDO", "1"),
]

path = get_result_path("color_memory")

run(base_defines, "scene={}_depth={}".format(scene, scene_depth), path)