torchbenchmark/models/dlrm/dlrm_data_caffe2.py [376:621]: - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - def generate_stack_distance(cumm_val, cumm_dist, max_i, i, enable_padding=False): u = ra.rand(1) if i < max_i: # only generate stack distances up to the number of new references seen so far j = bisect.bisect(cumm_val, i) - 1 fi = cumm_dist[j] u *= fi # shrink distribution support to exclude last values elif enable_padding: # WARNING: disable generation of new references (once all have been seen) fi = cumm_dist[0] u = (1.0 - fi) * u + fi # remap distribution support to exclude first value for (j, f) in enumerate(cumm_dist): if u <= f: return cumm_val[j] # WARNING: global define, must be consistent across all synthetic functions cache_line_size = 1 def trace_generate_lru( line_accesses, list_sd, cumm_sd, out_trace_len, enable_padding=False ): max_sd = list_sd[-1] l = len(line_accesses) i = 0 ztrace = [] for _ in range(out_trace_len): sd = generate_stack_distance(list_sd, cumm_sd, max_sd, i, enable_padding) mem_ref_within_line = 0 # floor(ra.rand(1)*cache_line_size) #0 # generate memory reference if sd == 0: # new reference # line_ref = line_accesses.pop(0) line_accesses.append(line_ref) mem_ref = np.uint64(line_ref * cache_line_size + mem_ref_within_line) i += 1 else: # existing reference # line_ref = line_accesses[l - sd] mem_ref = np.uint64(line_ref * cache_line_size + mem_ref_within_line) line_accesses.pop(l - sd) line_accesses.append(line_ref) # save generated memory reference ztrace.append(mem_ref) return ztrace def trace_generate_rand( line_accesses, list_sd, cumm_sd, out_trace_len, enable_padding=False ): max_sd = list_sd[-1] l = len(line_accesses) # !!!Unique, i = 0 ztrace = [] for _ in range(out_trace_len): sd = generate_stack_distance(list_sd, cumm_sd, max_sd, i, enable_padding) mem_ref_within_line = 0 # floor(ra.rand(1)*cache_line_size) #0 # generate memory reference if sd == 0: # new reference # line_ref = line_accesses.pop(0) line_accesses.append(line_ref) mem_ref = np.uint64(line_ref * cache_line_size + mem_ref_within_line) i += 1 else: # existing reference # line_ref = line_accesses[l - sd] mem_ref = np.uint64(line_ref * cache_line_size + mem_ref_within_line) ztrace.append(mem_ref) return ztrace def trace_profile(trace, enable_padding=False): # number of elements in the array (assuming 1D) # n = trace.size rstack = [] # S stack_distances = [] # SDS line_accesses = [] # L for x in trace: r = np.uint64(x / cache_line_size) l = len(rstack) try: # found # i = rstack.index(r) # WARNING: I believe below is the correct depth in terms of meaning of the # algorithm, but that is not what seems to be in the paper alg. # -1 can be subtracted if we defined the distance between # consecutive accesses (e.g. r, r) as 0 rather than 1. sd = l - i # - 1 # push r to the end of stack_distances stack_distances.insert(0, sd) # remove r from its position and insert to the top of stack rstack.pop(i) # rstack.remove(r) rstack.insert(l - 1, r) except ValueError: # not found # sd = 0 # -1 # push r to the end of stack_distances/line_accesses stack_distances.insert(0, sd) line_accesses.insert(0, r) # push r to the top of stack rstack.insert(l, r) if enable_padding: # WARNING: notice that as the ratio between the number of samples (l) # and cardinality (c) of a sample increases the probability of # generating a sample gets smaller and smaller because there are # few new samples compared to repeated samples. This means that for a # long trace with relatively small cardinality it will take longer to # generate all new samples and therefore obtain full distribution support # and hence it takes longer for distribution to resemble the original. # Therefore, we may pad the number of new samples to be on par with # average number of samples l/c artificially. l = len(stack_distances) c = max(stack_distances) padding = int(np.ceil(l / c)) stack_distances = stack_distances + [0] * padding return (rstack, stack_distances, line_accesses) # auxiliary read/write routines def read_trace_from_file(file_path): try: with open(file_path) as f: if args.trace_file_binary_type: array = np.fromfile(f, dtype=np.uint64) trace = array.astype(np.uint64).tolist() else: line = f.readline() trace = list(map(lambda x: np.uint64(x), line.split(", "))) return trace except Exception: print("ERROR: no input trace file has been provided") def write_trace_to_file(file_path, trace): try: if args.trace_file_binary_type: with open(file_path, "wb+") as f: np.array(trace).astype(np.uint64).tofile(f) else: with open(file_path, "w+") as f: s = str(trace) f.write(s[1 : len(s) - 1]) except Exception: print("ERROR: no output trace file has been provided") def read_dist_from_file(file_path): try: with open(file_path, "r") as f: lines = f.read().splitlines() except Exception: print("Wrong file or file path") # read unique accesses unique_accesses = [int(el) for el in lines[0].split(", ")] # read cumulative distribution (elements are passed as two separate lists) list_sd = [int(el) for el in lines[1].split(", ")] cumm_sd = [float(el) for el in lines[2].split(", ")] return unique_accesses, list_sd, cumm_sd def write_dist_to_file(file_path, unique_accesses, list_sd, cumm_sd): try: with open(file_path, "w") as f: # unique_acesses s = str(unique_accesses) f.write(s[1 : len(s) - 1] + "\n") # list_sd s = str(list_sd) f.write(s[1 : len(s) - 1] + "\n") # cumm_sd s = str(cumm_sd) f.write(s[1 : len(s) - 1] + "\n") except Exception: print("Wrong file or file path") if __name__ == "__main__": import sys import operator import argparse ### parse arguments ### parser = argparse.ArgumentParser(description="Generate Synthetic Distributions") parser.add_argument("--trace-file", type=str, default="./input/trace.log") parser.add_argument("--trace-file-binary-type", type=bool, default=False) parser.add_argument("--trace-enable-padding", type=bool, default=False) parser.add_argument("--dist-file", type=str, default="./input/dist.log") parser.add_argument( "--synthetic-file", type=str, default="./input/trace_synthetic.log" ) parser.add_argument("--numpy-rand-seed", type=int, default=123) parser.add_argument("--print-precision", type=int, default=5) args = parser.parse_args() ### some basic setup ### np.random.seed(args.numpy_rand_seed) np.set_printoptions(precision=args.print_precision) ### read trace ### trace = read_trace_from_file(args.trace_file) # print(trace) ### profile trace ### (_, stack_distances, line_accesses) = trace_profile( trace, args.trace_enable_padding ) stack_distances.reverse() line_accesses.reverse() # print(line_accesses) # print(stack_distances) ### compute probability distribution ### # count items l = len(stack_distances) dc = sorted( collections.Counter(stack_distances).items(), key=operator.itemgetter(0) ) # create a distribution list_sd = list(map(lambda tuple_x_k: tuple_x_k[0], dc)) # x = tuple_x_k[0] dist_sd = list( map(lambda tuple_x_k: tuple_x_k[1] / float(l), dc) ) # k = tuple_x_k[1] cumm_sd = [] # np.cumsum(dc).tolist() #prefixsum for i, (_, k) in enumerate(dc): if i == 0: cumm_sd.append(k / float(l)) else: # add the 2nd element of the i-th tuple in the dist_sd list cumm_sd.append(cumm_sd[i - 1] + (k / float(l))) ### write stack_distance and line_accesses to a file ### write_dist_to_file(args.dist_file, line_accesses, list_sd, cumm_sd) ### generate correspondinf synthetic ### # line_accesses, list_sd, cumm_sd = read_dist_from_file(args.dist_file) synthetic_trace = trace_generate_lru( line_accesses, list_sd, cumm_sd, len(trace), args.trace_enable_padding ) # synthetic_trace = trace_generate_rand( # line_accesses, list_sd, cumm_sd, len(trace), args.trace_enable_padding # ) write_trace_to_file(args.synthetic_file, synthetic_trace) - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - torchbenchmark/models/dlrm/dlrm_data_pytorch.py [856:1102]: - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - def generate_stack_distance(cumm_val, cumm_dist, max_i, i, enable_padding=False): u = ra.rand(1) if i < max_i: # only generate stack distances up to the number of new references seen so far j = bisect.bisect(cumm_val, i) - 1 fi = cumm_dist[j] u *= fi # shrink distribution support to exclude last values elif enable_padding: # WARNING: disable generation of new references (once all have been seen) fi = cumm_dist[0] u = (1.0 - fi) * u + fi # remap distribution support to exclude first value for (j, f) in enumerate(cumm_dist): if u <= f: return cumm_val[j] # WARNING: global define, must be consistent across all synthetic functions cache_line_size = 1 def trace_generate_lru( line_accesses, list_sd, cumm_sd, out_trace_len, enable_padding=False ): max_sd = list_sd[-1] l = len(line_accesses) i = 0 ztrace = [] for _ in range(out_trace_len): sd = generate_stack_distance(list_sd, cumm_sd, max_sd, i, enable_padding) mem_ref_within_line = 0 # floor(ra.rand(1)*cache_line_size) #0 # generate memory reference if sd == 0: # new reference # line_ref = line_accesses.pop(0) line_accesses.append(line_ref) mem_ref = np.uint64(line_ref * cache_line_size + mem_ref_within_line) i += 1 else: # existing reference # line_ref = line_accesses[l - sd] mem_ref = np.uint64(line_ref * cache_line_size + mem_ref_within_line) line_accesses.pop(l - sd) line_accesses.append(line_ref) # save generated memory reference ztrace.append(mem_ref) return ztrace def trace_generate_rand( line_accesses, list_sd, cumm_sd, out_trace_len, enable_padding=False ): max_sd = list_sd[-1] l = len(line_accesses) # !!!Unique, i = 0 ztrace = [] for _ in range(out_trace_len): sd = generate_stack_distance(list_sd, cumm_sd, max_sd, i, enable_padding) mem_ref_within_line = 0 # floor(ra.rand(1)*cache_line_size) #0 # generate memory reference if sd == 0: # new reference # line_ref = line_accesses.pop(0) line_accesses.append(line_ref) mem_ref = np.uint64(line_ref * cache_line_size + mem_ref_within_line) i += 1 else: # existing reference # line_ref = line_accesses[l - sd] mem_ref = np.uint64(line_ref * cache_line_size + mem_ref_within_line) ztrace.append(mem_ref) return ztrace def trace_profile(trace, enable_padding=False): # number of elements in the array (assuming 1D) # n = trace.size rstack = [] # S stack_distances = [] # SDS line_accesses = [] # L for x in trace: r = np.uint64(x / cache_line_size) l = len(rstack) try: # found # i = rstack.index(r) # WARNING: I believe below is the correct depth in terms of meaning of the # algorithm, but that is not what seems to be in the paper alg. # -1 can be subtracted if we defined the distance between # consecutive accesses (e.g. r, r) as 0 rather than 1. sd = l - i # - 1 # push r to the end of stack_distances stack_distances.insert(0, sd) # remove r from its position and insert to the top of stack rstack.pop(i) # rstack.remove(r) rstack.insert(l - 1, r) except ValueError: # not found # sd = 0 # -1 # push r to the end of stack_distances/line_accesses stack_distances.insert(0, sd) line_accesses.insert(0, r) # push r to the top of stack rstack.insert(l, r) if enable_padding: # WARNING: notice that as the ratio between the number of samples (l) # and cardinality (c) of a sample increases the probability of # generating a sample gets smaller and smaller because there are # few new samples compared to repeated samples. This means that for a # long trace with relatively small cardinality it will take longer to # generate all new samples and therefore obtain full distribution support # and hence it takes longer for distribution to resemble the original. # Therefore, we may pad the number of new samples to be on par with # average number of samples l/c artificially. l = len(stack_distances) c = max(stack_distances) padding = int(np.ceil(l / c)) stack_distances = stack_distances + [0] * padding return (rstack, stack_distances, line_accesses) # auxiliary read/write routines def read_trace_from_file(file_path): try: with open(file_path) as f: if args.trace_file_binary_type: array = np.fromfile(f, dtype=np.uint64) trace = array.astype(np.uint64).tolist() else: line = f.readline() trace = list(map(lambda x: np.uint64(x), line.split(", "))) return trace except Exception: print("ERROR: no input trace file has been provided") def write_trace_to_file(file_path, trace): try: if args.trace_file_binary_type: with open(file_path, "wb+") as f: np.array(trace).astype(np.uint64).tofile(f) else: with open(file_path, "w+") as f: s = str(trace) f.write(s[1 : len(s) - 1]) except Exception: print("ERROR: no output trace file has been provided") def read_dist_from_file(file_path): try: with open(file_path, "r") as f: lines = f.read().splitlines() except Exception: print("Wrong file or file path") # read unique accesses unique_accesses = [int(el) for el in lines[0].split(", ")] # read cumulative distribution (elements are passed as two separate lists) list_sd = [int(el) for el in lines[1].split(", ")] cumm_sd = [float(el) for el in lines[2].split(", ")] return unique_accesses, list_sd, cumm_sd def write_dist_to_file(file_path, unique_accesses, list_sd, cumm_sd): try: with open(file_path, "w") as f: # unique_acesses s = str(unique_accesses) f.write(s[1 : len(s) - 1] + "\n") # list_sd s = str(list_sd) f.write(s[1 : len(s) - 1] + "\n") # cumm_sd s = str(cumm_sd) f.write(s[1 : len(s) - 1] + "\n") except Exception: print("Wrong file or file path") if __name__ == "__main__": import sys import operator import argparse ### parse arguments ### parser = argparse.ArgumentParser(description="Generate Synthetic Distributions") parser.add_argument("--trace-file", type=str, default="./input/trace.log") parser.add_argument("--trace-file-binary-type", type=bool, default=False) parser.add_argument("--trace-enable-padding", type=bool, default=False) parser.add_argument("--dist-file", type=str, default="./input/dist.log") parser.add_argument( "--synthetic-file", type=str, default="./input/trace_synthetic.log" ) parser.add_argument("--numpy-rand-seed", type=int, default=123) parser.add_argument("--print-precision", type=int, default=5) args = parser.parse_args() ### some basic setup ### np.random.seed(args.numpy_rand_seed) np.set_printoptions(precision=args.print_precision) ### read trace ### trace = read_trace_from_file(args.trace_file) # print(trace) ### profile trace ### (_, stack_distances, line_accesses) = trace_profile( trace, args.trace_enable_padding ) stack_distances.reverse() line_accesses.reverse() # print(line_accesses) # print(stack_distances) ### compute probability distribution ### # count items l = len(stack_distances) dc = sorted( collections.Counter(stack_distances).items(), key=operator.itemgetter(0) ) # create a distribution list_sd = list(map(lambda tuple_x_k: tuple_x_k[0], dc)) # x = tuple_x_k[0] dist_sd = list( map(lambda tuple_x_k: tuple_x_k[1] / float(l), dc) ) # k = tuple_x_k[1] cumm_sd = [] # np.cumsum(dc).tolist() #prefixsum for i, (_, k) in enumerate(dc): if i == 0: cumm_sd.append(k / float(l)) else: # add the 2nd element of the i-th tuple in the dist_sd list cumm_sd.append(cumm_sd[i - 1] + (k / float(l))) ### write stack_distance and line_accesses to a file ### write_dist_to_file(args.dist_file, line_accesses, list_sd, cumm_sd) ### generate correspondinf synthetic ### # line_accesses, list_sd, cumm_sd = read_dist_from_file(args.dist_file) synthetic_trace = trace_generate_lru( line_accesses, list_sd, cumm_sd, len(trace), args.trace_enable_padding ) # synthetic_trace = trace_generate_rand( # line_accesses, list_sd, cumm_sd, len(trace), args.trace_enable_padding # ) write_trace_to_file(args.synthetic_file, synthetic_trace) - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -