示例#1
0
def generate_data():
    a_blocks = list()
    b_blocks = list()
    n = NUMBER_OF_GENERATIONS if NUMBER_OF_GENERATIONS > 0 else NUMBER_OF_ITERATIONS
    for _ in range(n):
        a = np.random.random([BLOCKSIZE, BLOCKSIZE])
        b = np.random.random([BLOCKSIZE, BLOCKSIZE])

        # Only for evaluating in-place excution on Optane DC
        if INPUT_IN_NVRAM:
            a = np_persist(a)
            b = np_persist(b)

        a_blocks.append(a)
        b_blocks.append(b)

    return a_blocks, b_blocks
示例#2
0
def generate_data(input_size, output_size):
    a_blocks = list()
    b_blocks = list()
    c_blocks = list()

    for _ in range(input_size):
        a = np.random.random([BLOCKSIZE, BLOCKSIZE])
        b = np.random.random([BLOCKSIZE, BLOCKSIZE])
        # Only for evaluating in-place excution on Optane DC
        if INPUT_IN_NVRAM:
            a = np_persist(a)
            b = np_persist(b)
        a_blocks.append(a)
        b_blocks.append(b)

    for _ in range(output_size):
        c = np.zeros([BLOCKSIZE, BLOCKSIZE])
        if EXEC_IN_NVRAM:
            c = np_persist(c)
        c_blocks.append(c)

    return a_blocks, b_blocks, c_blocks
示例#3
0
def generate_data():
    blocks = list()
    n = NUMBER_OF_GENERATIONS if NUMBER_OF_GENERATIONS > 0 else NUMBER_OF_ITERATIONS
    for _ in range(n):
        values = np.random.f(10, 2, POINTS_PER_FRAGMENT)

        # Only for evaluating in-place excution on Optane DC
        if EXEC_IN_NVRAM:
            values = np_persist(values)

        blocks.append(values)

    bins = np.concatenate((np.arange(0, 10, 0.1), np.arange(10,
                                                            50), [np.infty]))

    return bins, blocks
示例#4
0
def generate_data():
    blocks = list()

    n = NUMBER_OF_GENERATIONS if NUMBER_OF_GENERATIONS > 0 else NUMBER_OF_ITERATIONS

    for _ in range(n):
        mat = np.array([
            np.random.random(DIMENSIONS) for __ in range(POINTS_PER_FRAGMENT)
        ])
        # Normalize all points between 0 and 1
        mat -= np.min(mat)
        mx = np.max(mat)
        if mx > 0.0:
            mat /= mx

        # Only for evaluating in-place excution on Optane DC
        if EXEC_IN_NVRAM:
            mat = np_persist(mat)

        blocks.append(mat)

    return blocks
示例#5
0
def block_sum(a: np.ndarray, b: np.ndarray):
    ret = a + b
    if RESULT_IN_NVRAM:
        ret = np_persist(ret)
    return ret
示例#6
0
 def persist_to_nvram(self):
     self.block = np_persist(self.block)
示例#7
0
 def persist_to_nvram(self):
     self.values = np_persist(self.values)
示例#8
0
            a_blocks.append(a)
            b_blocks.append(b)
            c_blocks.append(c[0])

        print("Generation time: %f" % (time.time() - start_time))

        evaluation_time = list()

        for _, row, column, result in zip(range(NUMBER_OF_ITERATIONS),
                                          cycle(a_blocks), cycle(b_blocks),
                                          cycle(c_blocks)):
            start_time = time.time()
            for a, b in zip(row, column):
                fma(a, b, c)
            if RESULT_IN_NVRAM and not EXEC_IN_NVRAM:
                c = np_persist(c)

            evaluation_time.append(time.time() - start_time)

        print("Execution times for the row x column multiplication: %r" %
              evaluation_time)

    # Are we in Memory Mode?
    # Easy to know: check if there is more than 1TiB of memory
    mem_bytes = os.sysconf('SC_PAGE_SIZE') * os.sysconf('SC_PHYS_PAGES')
    mem_tib = mem_bytes / (1024**4)
    mode = "MM" if mem_tib > 1 else "AD"

    with open("results_kernel.csv", "a") as f:
        for result in evaluation_time[-10:]:
            # Mangling everything with a ",".join
示例#9
0
 def persist_to_nvram(self):
     self.points = np_persist(self.points)