diff --git a/fast/2d5pt_bench_grid_size.csv b/fast/2d5pt_bench_grid_size.csv deleted file mode 100644 index 970df1d115..0000000000 --- a/fast/2d5pt_bench_grid_size.csv +++ /dev/null @@ -1,3 +0,0 @@ -GridSize xDSL Devito -256,0.0,0.01 -1024,0.0,0.01 diff --git a/fast/2d5pt_gpu_grid_runtimes.csv b/fast/2d5pt_gpu_grid_runtimes.csv deleted file mode 100644 index a836ee05a4..0000000000 --- a/fast/2d5pt_gpu_grid_runtimes.csv +++ /dev/null @@ -1,3 +0,0 @@ -Grid Size,Devito/xDSL,Devito -((2, 2), [0.0, 0.0, 0.001, 0.001, 0.001, 0.001, 0.0, 0.001, 0.001, 0.0], [0.00017300000000000006, 8.599999999999999e-05, 8.499999999999999e-05, 8.4e-05, 8.4e-05, 8.299999999999997e-05, 8.499999999999999e-05, 8.4e-05, 8.3e-05, 8.4e-05]) -((2, 4), [0.0, 0.0, 0.0, 0.0, 0.001, 0.0, 0.001, 0.0, 0.001, 0.001], [0.00010099999999999997, 8.699999999999999e-05, 8.6e-05, 8.4e-05, 8.6e-05, 8.3e-05, 8.299999999999997e-05, 8.3e-05, 8.4e-05, 8.199999999999999e-05]) diff --git a/fast/2d5pt_grid_runtimes.csv b/fast/2d5pt_grid_runtimes.csv deleted file mode 100644 index c05d1940b0..0000000000 --- a/fast/2d5pt_grid_runtimes.csv +++ /dev/null @@ -1,7 +0,0 @@ -Grid Size,Devito/xDSL,Devito/GCC -2048,2048,0.109,0.125764 -2048,4096,0.318,0.27019499999999996 -4096,4096,0.674,0.6884169999999998 -4096,8192,1.454,1.4310340000000001 -8192,8192,3.089,3.011858999999999 -8192,16384,6.1370000000000005,6.9759579999999985 diff --git a/fast/2d5pt_grid_runtimes.svg b/fast/2d5pt_grid_runtimes.svg deleted file mode 100644 index e1f1c2bd6c..0000000000 --- a/fast/2d5pt_grid_runtimes.svg +++ /dev/null @@ -1,776 +0,0 @@ - - - - - - - - 2023-05-07T15:42:23.184251 - image/svg+xml - - - Matplotlib v3.7.1, https://matplotlib.org/ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/fast/2d5pt_threads_devito.csv b/fast/2d5pt_threads_devito.csv deleted file mode 100644 index bde5309368..0000000000 --- a/fast/2d5pt_threads_devito.csv +++ /dev/null @@ -1,7 +0,0 @@ -Threads,Devito -(1, [0.002208000000000001, 0.0015280000000000005, 0.001472999999999999, 0.0014539999999999993, 0.0014550000000000001, 0.0014470000000000006, 0.0014360000000000002, 0.0014630000000000003, 0.0014350000000000005, 0.0014530000000000003]) -(2, [0.001522, 0.0015039999999999995, 0.0014729999999999997, 0.0014929999999999998, 0.0014839999999999999, 0.0014829999999999997, 0.0015129999999999996, 0.001486, 0.0014979999999999995, 0.0014999999999999998]) -(4, [0.0015759999999999997, 0.0015019999999999999, 0.00148, 0.0015100000000000005, 0.00151, 0.0014810000000000001, 0.001476, 0.0014740000000000003, 0.0014750000000000004, 0.001494]) -(8, [0.0011560000000000016, 0.0010660000000000018, 0.0010360000000000015, 0.0009800000000000013, 0.000964000000000001, 0.0009510000000000009, 0.000979000000000001, 0.000983000000000001, 0.001011000000000001, 0.0009460000000000007]) -(16, [0.001254000000000001, 0.0010400000000000016, 0.0007709999999999986, 0.0007799999999999987, 0.0007919999999999987, 0.0007839999999999987, 0.0007859999999999987, 0.0007809999999999985, 0.0007969999999999987, 0.0007849999999999986]) -(32, [0.0025570000000000007, 0.002603000000000002, 0.0027170000000000015, 0.002355000000000001, 0.0023100000000000004, 0.0024140000000000016, 0.0023169999999999996, 0.0030670000000000007, 0.002312000000000001, 0.002300000000000001]) diff --git a/fast/2d5pt_threads_xdsl.csv b/fast/2d5pt_threads_xdsl.csv deleted file mode 100644 index 77b81d7aae..0000000000 --- a/fast/2d5pt_threads_xdsl.csv +++ /dev/null @@ -1,7 +0,0 @@ -Threads,Devito/xDSL -(1, [0.003, 0.006, 0.003, 0.005, 0.005, 0.003, 0.002, 0.003, 0.005, 0.003]) -(2, [0.002, 0.002, 0.002, 0.003, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002]) -(4, [0.002, 0.001, 0.002, 0.002, 0.003, 0.002, 0.002, 0.002, 0.002, 0.002]) -(8, [0.002, 0.001, 0.002, 0.002, 0.001, 0.001, 0.002, 0.002, 0.001, 0.002]) -(16, [0.002, 0.005, 0.002, 0.002, 0.002, 0.001, 0.005, 0.002, 0.002, 0.002]) -(32, [0.005, 0.005, 0.003, 0.006, 0.005, 0.005, 0.005, 0.008, 0.004, 0.006]) diff --git a/fast/3d_diff_grid_runtimes.csv b/fast/3d_diff_grid_runtimes.csv deleted file mode 100644 index dc8531e346..0000000000 --- a/fast/3d_diff_grid_runtimes.csv +++ /dev/null @@ -1,12 +0,0 @@ -Grid Size,Devito/xDSL,Devito -((25, 25, 25), [0.0, 0.0, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.0], [0.0006849999999999996, 0.0006689999999999996, 0.0006749999999999996, 0.0006829999999999996, 0.0006769999999999995, 0.0006759999999999995, 0.0006739999999999998, 0.0006859999999999994, 0.0006749999999999996, 0.0006759999999999994]) -((25, 25, 50), [0.001, 0.002, 0.001, 0.002, 0.001, 0.001, 0.002, 0.002, 0.001, 0.001], [0.001180999999999999, 0.0010940000000000017, 0.0011140000000000015, 0.0011060000000000015, 0.0011060000000000013, 0.0011080000000000013, 0.0011040000000000017, 0.0011100000000000014, 0.0011160000000000013, 0.0011050000000000012]) -((25, 50, 50), [0.002, 0.003, 0.002, 0.003, 0.003, 0.002, 0.003, 0.002, 0.002, 0.002], [0.002446000000000001, 0.002274000000000002, 0.0022900000000000017, 0.002264000000000002, 0.002266000000000002, 0.002286000000000002, 0.002274000000000002, 0.0023020000000000015, 0.0022940000000000018, 0.0022840000000000017]) -((50, 50, 50), [0.005, 0.005, 0.005, 0.005, 0.005, 0.005, 0.005, 0.005, 0.004, 0.005], [0.004731999999999996, 0.004684999999999995, 0.004616999999999998, 0.0046279999999999984, 0.0046570000000000005, 0.00463, 0.004628, 0.004627999999999999, 0.004647000000000002, 0.004647000000000001]) -((50, 50, 100), [0.008, 0.009, 0.009, 0.008, 0.008, 0.008, 0.009, 0.008, 0.009, 0.008], [0.007850000000000008, 0.007606000000000006, 0.007662000000000002, 0.0076719999999999965, 0.007662999999999997, 0.007671999999999997, 0.007662999999999998, 0.007637000000000001, 0.007644999999999998, 0.007646999999999998]) -((50, 100, 100), [0.016, 0.017, 0.017, 0.017, 0.016, 0.017, 0.018, 0.018, 0.018, 0.017], [0.015632999999999994, 0.015381999999999988, 0.01534899999999999, 0.015382999999999983, 0.01538599999999999, 0.015383999999999988, 0.015349999999999987, 0.015371999999999988, 0.01566700000000001, 0.015753]) -((100, 100, 100), [0.033, 0.032, 0.032, 0.032, 0.032, 0.032, 0.033, 0.033, 0.033, 0.033], [0.03150999999999999, 0.03113500000000001, 0.031101000000000004, 0.03109400000000004, 0.03116200000000003, 0.031159000000000027, 0.031241000000000015, 0.031170000000000028, 0.031285000000000014, 0.031254999999999984]) -((100, 100, 200), [0.053, 0.054, 0.053, 0.054, 0.052, 0.054, 0.055, 0.054, 0.054, 0.054], [0.05675999999999998, 0.05593, 0.056949, 0.05753000000000001, 0.057545000000000034, 0.05740799999999999, 0.057413, 0.058486000000000024, 0.05747000000000001, 0.05757399999999999]) -((100, 200, 200), [0.128, 0.128, 0.125, 0.131, 0.126, 0.126, 0.125, 0.126, 0.123, 0.128], [0.152539, 0.14891100000000007, 0.13001499999999996, 0.13894499999999996, 0.14290999999999998, 0.14114400000000002, 0.14652800000000002, 0.14664700000000003, 0.14234200000000008, 0.142064]) -((200, 200, 200), [0.394, 0.40900000000000003, 0.394, 0.39, 0.396, 0.388, 0.404, 0.406, 0.40900000000000003, 0.389], [0.44038599999999994, 0.3770539999999997, 0.37931899999999985, 0.405373, 0.40441799999999983, 0.37735299999999977, 0.3893460000000001, 0.402881, 0.3689360000000001, 0.3869070000000002]) -((200, 200, 400), [0.8140000000000001, 0.804, 0.805, 0.8, 0.805, 0.806, 0.803, 0.803, 0.804, 0.803], [0.8724449999999997, 0.787226, 0.7972509999999997, 0.8083279999999999, 0.808991, 0.7839999999999998, 0.821152, 0.78316, 0.8320400000000006, 0.8136529999999996]) diff --git a/fast/Dockerfile-SC b/fast/Dockerfile-SC deleted file mode 100644 index 40e228222e..0000000000 --- a/fast/Dockerfile-SC +++ /dev/null @@ -1,19 +0,0 @@ -FROM ubuntu:22.04 - -# Install dependencies -RUN apt update \ - && apt install --yes --no-install-recommends git cmake build-essential ca-certificates ninja-build clang lld python3.10-dev pip -RUN git clone https://github.com/xdslproject/xdsl.git \ - && git clone https://github.com/devitocodes/devito.git \ - && git clone https://github.com/llvm/llvm-project.git -RUN cd llvm-project \ - && git checkout 89996621de073e43de7bed552037b10d2a0fdf80 -RUN mkdir llvm-project/build \ - && cd llvm-project/build \ - && cmake -G Ninja ../llvm -DLLVM_ENABLE_PROJECTS="mlir;clang;openmp" -DLLVM_BUILD_EXAMPLES=ON -DLLVM_TARGETS_TO_BUILD="X86" -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_ASSERTIONS=OFF -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DLLVM_ENABLE_LLD=ON -RUN cd llvm-project/build \ - && cmake --build . --target install -RUN cd xdsl \ - && pip install -r requirements.txt . -RUN cd devito \ - && pip install -r requirements.txt . diff --git a/fast/Makefile b/fast/Makefile deleted file mode 100644 index be7c2123ca..0000000000 --- a/fast/Makefile +++ /dev/null @@ -1,67 +0,0 @@ -NIXOS_CLANG_PREFIX ?= -CC = clang - -# Add flags for C -CFLAGS = -O3 - -# MODE decides if we want to compile for gpu or cpu -# might be extended to omp and others as well -MODE ?= cpu -DUMP ?= 1 - -ifeq ($(DUMP),0) -CFLAGS += -DNODUMP -endif - -# handle gpu flags for clang -ifeq ($(MODE),gpu) -CFLAGS += -lmlir_cuda_runtime -BENCH_OPTS_EXTRA += --gpu -else ifeq ($(MODE),cpu) -else ifeq ($(MODE),openmp) -BENCH_OPTS_EXTRA += --openmp -else ifeq ($(MODE),mpi) -BENCH_OPTS_EXTRA += --mpi -COMPARE_FLAGS += --mpi -endif - -MAIN_MLIR_FILE_PIPELINE := "builtin.module(canonicalize, convert-scf-to-cf, convert-cf-to-llvm{index-bitwidth=64}, convert-math-to-llvm, convert-arith-to-llvm{index-bitwidth=64}, $(MEMREF_TO_LLVM_PASS){index-bitwidth=64}, convert-func-to-llvm, reconcile-unrealized-casts, canonicalize)" - -.PHONY: %.bench -ifeq ($(DUMP), 0) -BENCH_OPTS_EXTRA = --no_output_dump -.PHONY: %.stencil.data -endif - -.PRECIOUS: %.stencil.data %.input.data - -# this creates the devito data. afaik devito requires gcc for this on my machine. Probably nixos related :S -# it calls the example script with the bench options, meaning it runs normal devito -# Can just do DEVITO_ARCH=gcc or DEVITO_ARCH=clang to pick up compiler -%.devito.data %.input.data: CC = gcc -%.devito.data %.input.data: - $(DEVITO_ENV) python3 fast_benchmarks.py $* $(BENCH_OPTS) $(BENCH_OPTS_EXTRA) - -# this calls the example file with the `-xdsl` flag so it dumps the mlir files -%.mlir %.main.o %.interop.o %.kernel.o %.out %.stencil.data: %.input.data - $(DEVITO_ENV) python3 fast_benchmarks.py $* $(BENCH_OPTS) $(BENCH_OPTS_EXTRA) -xdsl - -ifeq ($(DUMP),0) -%.bench: %.stencil.data %.devito.data - @echo "Done with no dumps, skipping output comparison" -else -%.bench: %.stencil.data %.devito.data - python3 compare.py --name $(patsubst %.bench,%,$@) $(BENCH_OPTS) $(COMPARE_FLAGS) -endif - - -#python3 compare.py $(BENCH_OPTS) --name $(patsubst %.bench,%,$@) - -.PHONY: %.bench clean - -# remove all intermediates and results -clean: - rm -f *.mlir - rm -f *.o - rm -f *.data - rm -f *.out \ No newline at end of file diff --git a/fast/auto_benchmark.py b/fast/auto_benchmark.py deleted file mode 100644 index edc10de842..0000000000 --- a/fast/auto_benchmark.py +++ /dev/null @@ -1,125 +0,0 @@ -from runner import run_benchmark, PerfReport -import csv - -dims = {"2d5pt": 2, "3d_diff": 3} - -def thread_scale(name: str, qos: str = 'standard'): - flags = '-nt 100 --xdsl --devito --openmp' - shape = [20000, 20000] - env_base = "OMP_PLACES=cores" - runs = 10 - - raw_results = [] - - result_lines = [] - - for num_threads in (1, 2, 4, 8, 16, 32, 64, 128): - env = env_base + f' OMP_NUM_THREADS={num_threads}' - results = run_benchmark( - ranks=1, - cpus_per_rank=num_threads, - name=name, - shape=shape, - flags=flags, - runs=runs, - env=env - ) - raw_results.extend(results) - - for res in results: - res.report() - assert len(res.times) == 1 - result_lines.append(( - num_threads, res.impl_name, res.times[0] - )) - # write csv file - with open(f'{name}_grid_runtimes.csv', 'w') as f: - w = csv.writer(f) - w.writerow(['num_threads', 'implementation', 'time']) - w.writerows(result_lines) - - # write raw data as json lines - with open(f'{name}_grid_runtimes.json', 'w') as f: - for r in raw_results: - f.write(r.to_json() + '\n') - - -def mpi_scale_2d5pt(qos="standard"): - flags = '-nt 100 --xdsl --devito --openmp --mpi' - cpus_per_rank=4 - env = f"OMP_PLACES=cores OMP_NUM_THREADS={cpus_per_rank} DEVITO_MPI=1" - shape = [2000, 2000] - runs = 5 - - raw_results = [] - - result_lines = [] - - for ranks in (1, 2, 4, 8, 16, 32, 64, 128): - results = run_benchmark( - ranks=ranks, - cpus_per_rank=cpus_per_rank, - name='2d5pt', - shape=shape, - flags=flags, - runs=runs, - env=env, - qos=qos, - ) - raw_results.extend(results) - - for res in results: - res.report() - result_lines.append(( - ranks, res.impl_name, sum(res.times) / len(res.times) - )) - # write csv file - with open(f'2d5pt_mpi_runtimes.csv', 'w') as f: - w = csv.writer(f) - w.writerow(['ranks', 'implementation', 'time']) - w.writerows(result_lines) - - # write raw data as json lines - with open(f'2d5pt_mpi_runtimes.json', 'w') as f: - for r in raw_results: - f.write(r.to_json() + '\n') - -def mpi_thread_scale_2d5pt(qos="standard"): - flags = '-nt 100 --xdsl --devito --openmp --mpi' - ranks = 16 - env = f"OMP_PLACES=cores DEVITO_MPI=1" - shape = [20000, 20000] - runs = 5 - - raw_results = [] - - result_lines = [] - - for cpus_per_rank in (1, 2, 4, 8, 16, 32): - results = run_benchmark( - ranks=ranks, - cpus_per_rank=cpus_per_rank, - name='2d5pt', - shape=shape, - flags=flags, - runs=runs, - env=env + f' OMP_NUM_THREADS={cpus_per_rank}', - qos=qos, - ) - raw_results.extend(results) - - for res in results: - res.report() - result_lines.append(( - cpus_per_rank, res.impl_name, sum(res.times) / len(res.times) - )) - # write csv file - with open(f'2d5pt_mpi_threads_runtimes.csv', 'w') as f: - w = csv.writer(f) - w.writerow(['cpus', 'implementation', 'time']) - w.writerows(result_lines) - - # write raw data as json lines - with open(f'2d5pt_mpi_threads_runtimes.json', 'w') as f: - for r in raw_results: - f.write(r.to_json() + '\n') diff --git a/fast/compare.py b/fast/compare.py deleted file mode 100644 index bae1c3889b..0000000000 --- a/fast/compare.py +++ /dev/null @@ -1,106 +0,0 @@ -import argparse -import sys - -import numpy as np - -parser = argparse.ArgumentParser(description="Process arguments.") - -parser.add_argument( - "-d", "--shape", type=int, nargs="+", help="Number of grid points along each axis" -) -parser.add_argument( - "-so", "--space_order", default=2, type=int, help="Space order of the simulation" -) -parser.add_argument( - "-to", "--time_order", default=1, type=int, help="Time order of the simulation" -) -parser.add_argument( - "-nt", "--nt", default=10, type=int, help="Simulation time in millisecond" -) -parser.add_argument("-n", "--name", type=str, help="benchmark name") -parser.add_argument("--mpi", default=False, action="store_true") - -args, unknown = parser.parse_known_args() - -bench_name = args.name - - -def prod(iter): - carry = 1 - for x in iter: - carry *= x - return carry - - -dtype = np.float32 -shape = args.shape - -devito_file = bench_name + ".devito.data" -stencil_file = bench_name + ".stencil.data" - -devito_data = np.fromfile(devito_file, dtype=dtype) -stencil_data = np.fromfile(stencil_file, dtype=dtype) - -try: - assert prod(devito_data.shape) == prod(shape) -except: - raise AssertionError("Wrong shape specified to the compare script!") - -# find halo size: -# this assumes that halo is equal in all directions -ndims = len(shape) -# number of elements that are "too many". We have to divide them equally into the halo -total_elms = stencil_data.shape[0] - -for halo in range(0, 20): - if total_elms <= (prod(shape_elm + halo for shape_elm in shape)): - break - -assert total_elms == prod( - shape_elm + halo for shape_elm in shape -), "Could not correctly infer halo" - -assert halo - -# set to the number of "columns" of nodes -# this is a bit weird, but trust me. -nodes = 4 -if args.mpi: - print("Unmangling MPI gathered data") - # load data and re-order - stencil = np.zeros(args.shape) - local_dims = args.shape[0], args.shape[1] // nodes - for i in range(nodes): - for i in range(nodes): - local = stencil_data[(i * prod(local_dims)):((i+1) * prod(local_dims))].reshape(local_dims) - stencil[:,(i * local_dims[1]):((i+1) * local_dims[1])] = local - stencil_data = stencil -else: - - # reshape into expanded form - stencil_data = stencil_data.reshape(tuple(shape_elm + halo for shape_elm in shape)) - # cut off the halo - if len(shape) == 2: - stencil_data = stencil_data[(halo // 2) : -(halo // 2), (halo // 2) : -(halo // 2)] - if len(shape) == 3: - stencil_data = stencil_data[ - (halo // 2) : -(halo // 2), - (halo // 2) : -(halo // 2), - (halo // 2) : -(halo // 2), - ] - - -# reshape into normal shape -devito_data = devito_data.reshape(shape) -error_data = devito_data - stencil_data - -print("Max error: {}".format(np.absolute(error_data).max())) -print(f"Mean Squred Error: {(error_data**2).mean()}") -abs_max = np.maximum(np.absolute(devito_data), np.absolute(stencil_data)).max() -print("Max abs value: {}".format(abs_max)) - -devito_norm = np.linalg.norm(devito_data) -stencil_norm = np.linalg.norm(stencil_data) -print(f"Norms (Devito/xDSL) : \n{devito_norm}\n{stencil_norm}") -assert np.isclose(devito_norm, stencil_norm, rtol=1e-6) -assert np.isclose(stencil_data, devito_data, rtol=1e-6).all() diff --git a/fast/interop.c b/fast/interop.c deleted file mode 100644 index 3471217ae4..0000000000 --- a/fast/interop.c +++ /dev/null @@ -1,239 +0,0 @@ -#include -#include -#include -#include -#include - -typedef float f32; -typedef double f64; - -typedef int32_t i32; -typedef int64_t i64; - -typedef int8_t i8; - -#define MEMREF_STRUCT_DEF(dtype, rank) struct dtype ## _memref_r_ ## rank { \ - dtype *allocated; \ - dtype *aligned; \ - intptr_t offset; \ - intptr_t sizes[rank]; \ - intptr_t strides[rank]; \ -}; \ - -#ifndef OUTFILE_NAME -#define OUTFILE_NAME "result.data" -#endif - -#ifndef INFILE_NAME -#define INFILE_NAME "input.data" -#endif - -// define memref rank 1 to 3 for f32, f64, i32, i64 -// these will be named f32_memref_r_2 for example - -MEMREF_STRUCT_DEF(i8, 1) -MEMREF_STRUCT_DEF(i8, 2) -MEMREF_STRUCT_DEF(i8, 3) - -MEMREF_STRUCT_DEF(f32, 1) -MEMREF_STRUCT_DEF(f32, 2) -MEMREF_STRUCT_DEF(f32, 3) - -MEMREF_STRUCT_DEF(i32, 1) -MEMREF_STRUCT_DEF(i32, 2) -MEMREF_STRUCT_DEF(i32, 3) - -MEMREF_STRUCT_DEF(f64, 1) -MEMREF_STRUCT_DEF(f64, 2) -MEMREF_STRUCT_DEF(f64, 3) - -MEMREF_STRUCT_DEF(i64, 1) -MEMREF_STRUCT_DEF(i64, 2) -MEMREF_STRUCT_DEF(i64, 3) - - -// code for packing/unpacking memrefs to/from args -// please don't look at this too closely here: -#define REP0(X) -#define REP1(X) X ## _1 -#define REP2(X) REP1(X) , X ## _2 -#define REP3(X) REP2(X) , X ## _3 -#define REP4(X) REP3(X) , X ## _4 -#define REP5(X) REP4(X) , X ## _5 -#define REP6(X) REP5(X) , X ## _6 -#define REP7(X) REP6(X) , X ## _7 -#define REP8(X) REP7(X) , X ## _8 -#define REP9(X) REP8(X) , X ## _9 -#define REP10(X) REP9(X) , X ## _10 - - -#define UNPACK_REP0(X) -#define UNPACK_REP1(X) X[0] -#define UNPACK_REP2(X) UNPACK_REP1(X) , X[1] -#define UNPACK_REP3(X) UNPACK_REP2(X) , X[2] -#define UNPACK_REP4(X) UNPACK_REP3(X) , X[3] -#define UNPACK_REP5(X) UNPACK_REP4(X) , X[4] -#define UNPACK_REP6(X) UNPACK_REP5(X) , X[5] -#define UNPACK_REP7(X) UNPACK_REP6(X) , X[6] -#define UNPACK_REP8(X) UNPACK_REP7(X) , X[7] -#define UNPACK_REP9(X) UNPACK_REP8(X) , X[8] -#define UNPACK_REP10(X) UNPACK_REP9(X) , X[9] - -#define UNPACK_NO_COMMA_REP0(X) -#define UNPACK_NO_COMMA_REP1(X) X[0] -#define UNPACK_NO_COMMA_REP2(X) UNPACK_NO_COMMA_REP1(X) X[1] -#define UNPACK_NO_COMMA_REP3(X) UNPACK_NO_COMMA_REP2(X) X[2] -#define UNPACK_NO_COMMA_REP4(X) UNPACK_NO_COMMA_REP3(X) X[3] -#define UNPACK_NO_COMMA_REP5(X) UNPACK_NO_COMMA_REP4(X) X[4] -#define UNPACK_NO_COMMA_REP6(X) UNPACK_NO_COMMA_REP5(X) X[5] -#define UNPACK_NO_COMMA_REP7(X) UNPACK_NO_COMMA_REP6(X) X[6] -#define UNPACK_NO_COMMA_REP8(X) UNPACK_NO_COMMA_REP7(X) X[7] -#define UNPACK_NO_COMMA_REP9(X) UNPACK_NO_COMMA_REP8(X) X[8] -#define UNPACK_NO_COMMA_REP10(X) UNPACK_NO_COMMA_REP9(X) X[9] - -// oh god, this is unholy: - -#define MEMREF_AS_ARGS_DEF(prefix, dtype, rank) dtype * prefix ## allocated, dtype * prefix ## aligned, intptr_t prefix ## offset, REP ## rank (intptr_t prefix ## sizes), REP ## rank (intptr_t prefix ## strides) - -#define COLLECT_MEMREF_ARGS_INTO(prefix, dtype, rank, name) struct dtype ## _memref_r_ ## rank name = { prefix ## allocated, prefix ## aligned, prefix ## offset, REP ## rank (prefix ## sizes), REP ## rank (prefix ## strides) } - -#define MEMREF_TO_ARGS(ref, rank) ref.allocated, ref.aligned, ref.offset, UNPACK_REP ## rank (ref.sizes), UNPACK_REP ## rank (ref.strides) - -// dumping memref macros: - -#if NODUMP -#define DUMP_MEMREF(fname, name, dtype, rank) \ - { \ - printf("Skipping output dumping!\n"); \ - } -#else -#define DUMP_MEMREF(fname, name, dtype, rank) \ - { \ - FILE *f = fopen(fname, "w"); \ - fwrite(name.aligned, sizeof(dtype), 1 UNPACK_NO_COMMA_REP##rank(*name.sizes), f); \ - fclose(f); \ - } -#endif - -// linearized accesses: - -#define LIN_ACCESS2(ref, x, y) ref.aligned[(x) * ref.sizes[1] + (y)] -#define LIN_ACCESS3(ref, x, y, z) ref.aligned[(x) * ref.sizes[1] * ref.sizes[2] + (y) * ref.sizes[2] + (z)] - -// dumping methods: - -#define GENERATE_DUMPING_FUNC(dtype, rank) void dump_memref_ ## dtype ## _rank_ ## rank (MEMREF_AS_ARGS_DEF(my, dtype, rank)) { \ - COLLECT_MEMREF_ARGS_INTO(my, dtype, rank, my_memref); \ - DUMP_MEMREF(OUTFILE_NAME, my_memref, dtype, rank) \ -} - -// generate function defs: - -GENERATE_DUMPING_FUNC(f32, 1) -GENERATE_DUMPING_FUNC(f32, 2) -GENERATE_DUMPING_FUNC(f32, 3) - -GENERATE_DUMPING_FUNC(f64, 1) -GENERATE_DUMPING_FUNC(f64, 2) -GENERATE_DUMPING_FUNC(f64, 3) - -GENERATE_DUMPING_FUNC(i32, 1) -GENERATE_DUMPING_FUNC(i32, 2) -GENERATE_DUMPING_FUNC(i32, 3) - -GENERATE_DUMPING_FUNC(i64, 1) -GENERATE_DUMPING_FUNC(i64, 2) -GENERATE_DUMPING_FUNC(i64, 3) - -/* -This file provides the following functions for MLIR: - -func.func private @dump_memref_i32_rank_1(memref) -> () -func.func private @dump_memref_f32_rank_1(memref) -> () -func.func private @dump_memref_i64_rank_1(memref) -> () -func.func private @dump_memref_f64_rank_1(memref) -> () - -func.func private @dump_memref_i32_rank_2(memref) -> () -func.func private @dump_memref_f32_rank_2(memref) -> () -func.func private @dump_memref_i64_rank_2(memref) -> () -func.func private @dump_memref_f64_rank_2(memref) -> () - -func.func private @dump_memref_i32_rank_3(memref) -> () -func.func private @dump_memref_f32_rank_3(memref) -> () -func.func private @dump_memref_i64_rank_3(memref) -> () -func.func private @dump_memref_f64_rank_3(memref) -> () - -You can call them using: - -func.call @dump_memref_f64_rank_3(%ref) : (memref) -> () - -or any other signature as provided above - -The output file will be outfile - -*/ - -const struct i8_memref_r_1 load_memref(char* fname, size_t length) { - void* ptr = aligned_alloc(64, length); - struct i8_memref_r_1 ref = {ptr, ptr, 0, length, 1}; - FILE* f = fopen(fname,"r"); - size_t num = fread(ptr, 1, length, f); - if (num != length) { - printf("WARN: file read failed! Only read %ld bytes!\n", num); - } - fclose(f); - return ref; -} - -struct i8_memref_r_1 load_input(size_t length) { - return load_memref(INFILE_NAME, length); -} - -void print_i32(int n) -{ - printf("%d\n", n); -} - -double timer_start() { - // return a number representing the current point in time - // it might be offset by a fixed ammount - struct timespec t; - clock_gettime(CLOCK_MONOTONIC, &t); - return (t.tv_sec) + (t.tv_nsec * 1e-9); -} - -double timer_end(double start) { - // return time elaspes since start in seconds - return (timer_start() - start); -} - -#ifdef MPI_ENABLE - -extern int MPI_Comm_rank(int comm, int *rank); - -void print_halo_send_info(int dest, int ex, i64 x0, i64 y0, i64 h, i64 w) { - int rank; - MPI_Comm_rank(1140850688, &rank); - i64 x1 = x0 + h-1; - i64 y1 = y0 + w-1; - printf("MPI send ex%i [%li:%li,%li:%li] %i -> %i\n",ex, x0, x1, y0, y1, rank, dest); -} - -void print_halo_recv_info(int src, int ex, i64 x0, i64 y0, i64 h, i64 w) { - int rank; - MPI_Comm_rank(1140850688, &rank); - i64 x1 = x0 + h-1; - i64 y1 = y0 + w-1; - printf("MPI recv ex%i [%li:%li,%li:%li] %i <- %i\n",ex, x0, x1, y0, y1, rank, src); -} - -void dump_memref_per_rank(MEMREF_AS_ARGS_DEF(my, f32, 2), i64 index) { - COLLECT_MEMREF_ARGS_INTO(my, f32, 2, my_memref); - char name[512]; - int rank; - MPI_Comm_rank(1140850688, &rank); - sprintf(name, "result-rank-%i-buff-%" PRId64 ".data", rank, index); - DUMP_MEMREF(name, my_memref, f32, 2) -} - -#endif diff --git a/fast/mfe_2D.py b/fast/mfe_2D.py deleted file mode 100644 index 42e0ec213b..0000000000 --- a/fast/mfe_2D.py +++ /dev/null @@ -1,73 +0,0 @@ -# A 2D heat diffusion using Devito -# BC modelling included -# PyVista plotting included - -import argparse -import numpy as np - -from devito import Grid, TimeFunction, Eq, solve, Operator, Constant, norm, XDSLOperator -from examples.seismic import plot_image -from examples.cfd import init_hat - -parser = argparse.ArgumentParser(description='Process arguments.') - -parser.add_argument("-d", "--shape", default=(11, 11), type=int, nargs="+", - help="Number of grid points along each axis") -parser.add_argument("-so", "--space_order", default=2, - type=int, help="Space order of the simulation") -parser.add_argument("-to", "--time_order", default=1, - type=int, help="Time order of the simulation") -parser.add_argument("-nt", "--nt", default=40, - type=int, help="Simulation time in millisecond") -parser.add_argument("-bls", "--blevels", default=2, type=int, nargs="+", - help="Block levels") -parser.add_argument("-plot", "--plot", default=False, type=bool, help="Plot3D") -args = parser.parse_args() - -# Some variable declarations -nx, ny = args.shape -nt = args.nt -nu = .5 -dx = 1. / (nx - 1) -dy = 1. / (ny - 1) -sigma = .25 - -dt = sigma * dx * dy / nu -so = args.space_order -to = args.time_order - -print("dx %s, dy %s" % (dx, dy)) - -grid = Grid(shape=(nx, ny), extent=(2., 2.)) -u = TimeFunction(name='u', grid=grid, space_order=so) - -# Reset our data field and ICs -#init_hat(field=u.data[0], dx=dx, dy=dy, value=1.) -u.data[:, 2:3, 2:3] = 1 - -a = Constant(name='a') -# Create an equation with second-order derivatives -# eq = Eq(u.dt, a * u.laplace, subdomain=grid.interior) -eq = Eq(u.dt, a * u.laplace) -stencil = solve(eq, u.forward) -eq_stencil = Eq(u.forward, stencil) - -# Create boundary condition expressions -x, y = grid.dimensions -t = grid.stepping_dim - -initdata = u.data[:] -op = Operator([eq_stencil], name='DevitoOperator') -op.apply(time=nt, dt=dt, a=nu) -print(u.data[0, :]) -print("Devito Field norm is:", norm(u)) - -u.data[:, : , :] = 0 -u.data[:, 2:3 , 2:3] = 1 -# Reset data and run XDSLOperator -#init_hat(field=u.data[0], dx=dx, dy=dy, value=1.) -xdslop = Operator([eq_stencil], name='XDSLOperator') -xdslop.apply(time=nt, dt=dt, a=nu) -print(u.data[0, :]) - -print("XDSL Field norm is:", norm(u)) diff --git a/fast/nd_nwave_devito_nodamp.py b/fast/nd_nwave_devito_nodamp.py deleted file mode 100644 index 5860575b51..0000000000 --- a/fast/nd_nwave_devito_nodamp.py +++ /dev/null @@ -1,140 +0,0 @@ -# Based on the implementation of the Devito acoustic example implementation -# Not using Devito's source injection abstraction -import numpy as np -from devito import TimeFunction, Eq, Operator, solve, norm, XDSLOperator -from examples.seismic import RickerSource -from examples.seismic import Model, TimeAxis - -from devito.tools import as_tuple - -import argparse - -parser = argparse.ArgumentParser(description='Process arguments.') - -parser.add_argument("-d", "--shape", default=(11, 11, 11), type=int, nargs="+", - help="Number of grid points along each axis") -parser.add_argument("-so", "--space_order", default=4, - type=int, help="Space order of the simulation") -parser.add_argument("-to", "--time_order", default=2, - type=int, help="Time order of the simulation") -parser.add_argument("-nt", "--nt", default=200, - type=int, help="Simulation time in millisecond") -parser.add_argument("-bls", "--blevels", default=2, type=int, nargs="+", - help="Block levels") -parser.add_argument("-plot", "--plot", default=False, type=bool, help="Plot3D") -args = parser.parse_args() - - -def plot_3dfunc(u): - # Plot a 3D structured grid using pyvista - - import matplotlib.pyplot as plt - import pyvista as pv - cmap = plt.colormaps["viridis"] - values = u.data[0, :, :, :] - vistagrid = pv.UniformGrid() - vistagrid.dimensions = np.array(values.shape) + 1 - vistagrid.spacing = (1, 1, 1) - vistagrid.origin = (0, 0, 0) # The bottom left corner of the data set - vistagrid.cell_data["values"] = values.flatten(order="F") - vistaslices = vistagrid.slice_orthogonal() - # vistagrid.plot(show_edges=True) - vistaslices.plot(cmap=cmap) - - -# Define a physical size -# nx, ny, nz = args.shape -nt = args.nt - -shape = (args.shape) # Number of grid point (nx, ny, nz) -spacing = as_tuple(10.0 for _ in range(len(shape))) # Grid spacing in m. The domain size is now 1km by 1km -origin = as_tuple(0.0 for _ in range(len(shape))) # What is the location of the top left corner. -# This is necessary to define -# the absolute location of the source and receivers - -# Define a velocity profile. The velocity is in km/s -v = np.empty(shape, dtype=np.float32) -v[:, ..., :] = 1 - -# With the velocity and model size defined, we can create the seismic model that -# encapsulates this properties. We also define the size of the absorbing layer as -# 10 grid points -so = args.space_order -to = args.time_order - -model = Model(vp=v, origin=origin, shape=shape, spacing=spacing, - space_order=so, nbl=0) - -# plot_velocity(model) - -t0 = 0. # Simulation starts a t=0 -tn = nt # Simulation last 1 second (1000 ms) -dt = model.critical_dt # Time step from model grid spacing -print("dt is:", dt) - -time_range = TimeAxis(start=t0, stop=tn, step=dt) - -# The source is positioned at a $20m$ depth and at the middle of the -# $x$ axis ($x_{src}=500m$), -# with a peak wavelet frequency of $10Hz$. -f0 = 0.010 # Source peak frequency is 10Hz (0.010 kHz) -src = RickerSource(name='src', grid=model.grid, f0=f0, - npoint=1, time_range=time_range) - -# First, position source centrally in all dimensions, then set depth -src.coordinates.data[0, :] = np.array(model.domain_size) * .5 - -# We can plot the time signature to see the wavelet -#src.show() - -# Define the wavefield with the size of the model and the time dimension -u = TimeFunction(name="u", grid=model.grid, time_order=to, space_order=so) - -# We can now write the PDE -# pde = model.m * u.dt2 - u.laplace + model.damp * u.dt -# import pdb;pdb.set_trace() -pde = u.dt2 - u.laplace - -# The PDE representation is as on paper -pde - -stencil = Eq(u.forward, solve(pde, u.forward)) -stencil - -# Finally we define the source injection and receiver read function to generate -# the corresponding code -print(time_range) -src_term = src.inject(field=u.forward, expr=src * dt**2 / model.m) -op = Operator([stencil] + src_term, subs=model.spacing_map, name='DevitoOperator') -# Run with source and plot -op.apply(time=time_range.num-1, dt=model.critical_dt) - -if len(shape) == 3: - if args.plot: - plot_3dfunc(u) - -initdata = u.data[:] - -# Run more with no sources now (Not supported in xdsl) -op = Operator([stencil], name='DevitoOperator', opt='noop') -op.apply(time=time_range.num-1, dt=model.critical_dt) - -if len(shape) == 3: - if args.plot: - plot_3dfunc(u) - - -devito_output = u.copy() -print("Devito norm:", norm(u)) -print(f"devito output norm: {norm(devito_output)}") - -# Reset initial data -u.data[:] = initdata - -# Run more with no sources now (Not supported in xdsl) -xdslop = XDSLOperator([stencil], name='xDSLOperator') -xdslop.apply(time=time_range.num-1, dt=model.critical_dt) - -xdsl_output = u.copy() -print("XDSL norm:", norm(u)) -print(f"xdsl output norm: {norm(xdsl_output)}") diff --git a/fast/plot_grid_scale.py b/fast/plot_grid_scale.py deleted file mode 100644 index 14a4aa7338..0000000000 --- a/fast/plot_grid_scale.py +++ /dev/null @@ -1,70 +0,0 @@ - -from ast import literal_eval -from math import floor, log -import sys -import matplotlib.pyplot as plt -import numpy as np - -dims = {"2d5pt": 2, "3d_diff": 3} - -if len(sys.argv) < 2 or len(sys.argv) > 3: - print(f"usage: {sys.argv[0]} [first]") - print("plot data starting from the 0-indexed [first] line, defaulting to 0.") - sys.exit(1) - -benchmark = sys.argv[1] -first = int(sys.argv[2]) if len(sys.argv) > 2 else 0 - -csv_name = f"{benchmark}_grid_runtimes.csv" -pdf_name = f"devito_{benchmark}_probsize_cpu.pdf" - -def human_format(number: int): - units = ['', 'K', 'M', 'G', 'T', 'P'] - k = 1000.0 - magnitude = int(floor(log(number, k))) - if magnitude == 0 : - return str(number) - return '%.2f%s' % (number / k**magnitude, units[magnitude]) -try: - with open(csv_name, "r") as f: - lines = f.read().split("\n")[:-1] - header_line = lines[0].split(",") - x_label = header_line[0] - labels = header_line[1:] - - lines = list(map(literal_eval, lines[1+first:])) - - grid_size: list[tuple[int, ...]] = [] - values:dict[str, list[float]] = {} - for label in labels: - values[label] = [] - for line in lines: - grid_size.append(line[0]) - for i, label in enumerate(labels): - print(f"line {line} i {i}") - values[label].append(sum(line[i+1])/len(line[i+1])) - - x = np.arange(len(grid_size)) #type: ignore - width = 0.25 # the width of the bars - multiplier = 0 - - fig, ax = plt.subplots(layout="constrained") #type: ignore - - for attribute, measurement in values.items(): - offset = width * multiplier - rects = ax.bar(x + offset, measurement, width, label=attribute) #type: ignore - # ax.bar_label(rects, padding=3) - multiplier += 1 - - # Add some text for labels, title and custom x-axis tick labels, etc. - ax.set_ylabel("Time (s)") #type: ignore - ax.set_xlabel(x_label) # type: ignore - ax.set_xticks(x + width, grid_size) - ax.legend(loc="upper left", ncols=3) #type: ignore - fig.autofmt_xdate() - - plt.savefig(pdf_name, format="pdf") #type: ignore - plt.show() #type: ignore -except FileNotFoundError: - print(f'{csv_name} not found! Try running "python grid_scale.py {sys.argv[1]}" to generate it." ') - sys.exit(1) \ No newline at end of file diff --git a/fast/plot_thread.py b/fast/plot_thread.py deleted file mode 100644 index 7f27344c22..0000000000 --- a/fast/plot_thread.py +++ /dev/null @@ -1,74 +0,0 @@ - -from ast import literal_eval -import sys -import matplotlib.pyplot as plt -import numpy as np - -dims = {"2d5pt": 2, "3d_diff": 3} - -if len(sys.argv) < 2 or len(sys.argv) > 3: - print(f"usage: {sys.argv[0]} [first]") - print("plot data starting from the 0-indexed [first] line, defaulting to 0.") - sys.exit(1) - -benchmark = sys.argv[1] -first = int(sys.argv[2]) if len(sys.argv) > 2 else 0 - - -pdf_name = f"devito_{benchmark}_nthreads_cpu.pdf" - -modes = ["xdsl", "devito"] - -labels:list[str] = [] -nthreads: set[int] | list[int] = set() -x_label = "Threads" -values:dict[str, list[float]] = {} -for mode in modes: - csv_name = f"{benchmark}_threads_{mode}.csv" - try: - with open(csv_name, "r") as f: - lines = f.read().split("\n")[:-1] - - labels.append(mode) - - lines = list(map(literal_eval, lines[1+first:])) - if mode not in values.keys(): - values[mode] = [] - for line in lines: - nthreads.add(line[0]) - print(f"line {line}") - # line[1] is the list of runtimes - # Here I'm just plotting the average! - values[mode].append(sum(line[1])/len(line[1])) - - except FileNotFoundError: - print(f'{csv_name} not found! Try running "python grid_scale.py {sys.argv[1]} {mode}" to generate it." ') - sys.exit(1) -nthreads = list(nthreads) -nthreads.sort() - -print(nthreads) -print(labels) -print(values) -x = np.arange(len(nthreads)) #type: ignore -width = 0.25 # the width of the bars -multiplier = 0 - -fig, ax = plt.subplots(layout="constrained") #type: ignore - -for attribute, measurement in values.items(): - offset = width * multiplier - rects = ax.bar(x + offset, measurement, width, label=attribute) #type: ignore - # ax.bar_label(rects, padding=3) - multiplier += 1 - -# Add some text for labels, title and custom x-axis tick labels, etc. -ax.set_ylabel("Time (s)") #type: ignore -ax.set_xlabel(x_label) # type: ignore -ax.set_xticks(x + width, nthreads) -ax.legend(loc="upper left", ncols=3) #type: ignore -fig.autofmt_xdate() - -print(f"saving to {pdf_name}") -plt.savefig(pdf_name, format="pdf") #type: ignore -plt.show() #type: ignore \ No newline at end of file diff --git a/fast/results/.gitignore b/fast/results/.gitignore deleted file mode 100644 index 22f4e12573..0000000000 --- a/fast/results/.gitignore +++ /dev/null @@ -1,3 +0,0 @@ -*.data -*.data.rank* -*.data-split diff --git a/fast/results/viz.ipynb b/fast/results/viz.ipynb deleted file mode 100644 index 82953427df..0000000000 --- a/fast/results/viz.ipynb +++ /dev/null @@ -1,501 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "d5ca5cfa", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import seaborn as sns\n", - "import matplotlib.pyplot as plt\n", - "from math import prod" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "511bba3c", - "metadata": {}, - "outputs": [], - "source": [ - "sns.set_theme(style=\"white\")" - ] - }, - { - "cell_type": "code", - "execution_count": 113, - "id": "16aa2d61", - "metadata": {}, - "outputs": [], - "source": [ - "dims = 5,20\n", - "halo = (2,2),(2,2)\n", - "prob = '2d5pt'\n", - "dtype = np.float32\n", - "nodes = 4\n", - "mpi = False" - ] - }, - { - "cell_type": "code", - "execution_count": 116, - "id": "6d2c936f", - "metadata": {}, - "outputs": [], - "source": [ - "devito = np.fromfile(f\"{prob}.devito.data\", dtype).reshape(dims)\n", - "orig = np.fromfile(f\"{prob}.input.data\", dtype).reshape([(x + h[0] + h[1]) for x, h in zip(dims, halo)])[2:-2,2:-2]\n", - "\n", - "if mpi:\n", - " # load data and re-order\n", - " stencil_raw = np.fromfile(f\"{prob}.stencil.data\", dtype)[0:prod(dims)]\n", - " #stencil = stencil_raw.reshape(dims)\n", - " stencil = np.zeros(dims)\n", - " local_dims = dims[0], dims[1] // nodes\n", - " for i in range(nodes):\n", - " local = stencil_raw[(i * prod(local_dims)):((i+1) * prod(local_dims))].reshape(local_dims)\n", - " stencil[:,(i * local_dims[1]):((i+1) * local_dims[1])] = local\n", - "else:\n", - " stencil = np.fromfile(f\"{prob}.stencil.data\", dtype).reshape([(x + h[0] + h[1]) for x, h in zip(dims, halo)])[2:-2,2:-2]\n" - ] - }, - { - "cell_type": "code", - "execution_count": 117, - "id": "6dfd7284", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "f,(ax1,ax2,ax3, cbar_ax) = plt.subplots(1,4, \n", - " gridspec_kw={'width_ratios':[1,1,1,0.08]}, figsize=(15, 4), dpi=200)\n", - "ax1.get_shared_y_axes().join(ax2,ax3)\n", - "\n", - "m, M = min(devito.min(), stencil.min()), max(devito.max(), stencil.max())\n", - "\n", - "titles = iter(['input', 'Devito', 'xDSL'])\n", - "\n", - "kwargs = dict(vmin=m, vmax=M, linewidth=0.5 if dims[1] < 40 else 0) #\n", - "\n", - "for g, yticks in ((sns.heatmap(orig, linewidth=0.5 if dims[0] < 40 else 0, ax=ax1, cbar=False), True),\n", - " (sns.heatmap(devito,**kwargs, ax=ax2, cbar=False), False),\n", - " (sns.heatmap(stencil, **kwargs, ax=ax3, cbar_ax=cbar_ax), False)):\n", - " g.set_ylabel('')\n", - " g.set_xlabel('')\n", - " g.set(title=next(titles))\n", - " if not yticks:\n", - " g.set_yticks([])\n", - " tl = g.get_xticklabels()\n", - " g.set_xticklabels(tl, rotation=90)\n", - " tly = g.get_yticklabels()\n", - " g.set_yticklabels(tly, rotation=0)\n", - "f.suptitle('MPI run debugging')\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 118, - "id": "86e6d39b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "mean_squared_error=0.0018141906, max_error=0.203125\n" - ] - } - ], - "source": [ - "mean_squared_error = ((devito - stencil)**2).mean()\n", - "max_error = ((devito - stencil)**2).max()**0.5\n", - "print(f\"{mean_squared_error=}, {max_error=}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "a42cdd88", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.0074745542, 0.007474553771317005)" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "devito.min(), stencil.min()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "cb77d78b", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.007474553771317005, 0.0074745542)" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "stencil.min(), devito.min()" - ] - }, - { - "cell_type": "code", - "execution_count": 75, - "id": "2bdf127e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 75, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "t_s = 200\n", - "i = 1\n", - "raw = np.fromfile(f\"{prob}.stencil.data\", dtype)[i * t_s:(i+1)*t_s]\n", - "sns.heatmap(raw.reshape((20,10)), linewidth=0.5)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "47b9e824", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "05d913db", - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "r0 = raw[:prod(dims)//2].reshape((20,10))\n", - "r1 = raw[prod(dims)//2:].reshape((20,10))\n", - "\n", - "new_data = np.zeros((20,20))\n", - "new_data[:,:10] = r0\n", - "new_data[:,10:] = r1" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "1a8c784b", - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "sns.heatmap(new_data, linewidth=0.5)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "4d8af673", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[Text(0.5, 1.0, 'raw output')]" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "g=sns.heatmap(np.fromfile(f\"{prob}.stencil.data\", dtype)[200:400].reshape((20,10)), linewidths=.5)\n", - "g.set(title='raw output')" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "75f85e26", - "metadata": {}, - "outputs": [], - "source": [ - "orig[...,0:orig.shape[0]//2] = 1\n", - "orig[...,orig.shape[0]//2:] = 2\n", - "orig.tofile('2d5pt.input.data-split')" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "21b60d14", - "metadata": {}, - "outputs": [], - "source": [ - "for index, values in np.ndenumerate(orig):\n", - " orig[index] = index[0] * 100 + index[1]\n", - " \n", - "orig.tofile('2d5pt.input.data-split')" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "ef3bb14c", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "sns.heatmap(orig, linewidths=.5)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "1761c6a9", - "metadata": {}, - "outputs": [], - "source": [ - "r0 = np.fromfile('2d5pt.stencil.data.rank0', dtype).reshape((24,24))\n", - "r1 = np.fromfile('2d5pt.stencil.data.rank1', dtype).reshape((24,24))" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "e61c8d72", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "sns.heatmap(r0, linewidths=.5)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "4a282934", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "sns.heatmap(r1, linewidths=.5)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "a83a0c94", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "f,((ax1,ax2),(ax3,ax4)) = plt.subplots(2,2, figsize=(15, 12), dpi=200)\n", - "\n", - "axis = iter([ax1, ax2, ax3, ax4])\n", - " \n", - "for node in (0,1):\n", - " for buff in (0,1):\n", - " d = np.fromfile(f'result-rank-{node}-buff-{buff}.data', dtype=dtype).reshape((24,24))\n", - " g = sns.heatmap(d, linewidth=0.5,ax=next(axis))\n", - " g.set(title=f\"rank {node}, t{buff}\")\n", - " tl = g.get_xticklabels()\n", - " g.set_xticklabels(tl, rotation=90)\n", - " tly = g.get_yticklabels()\n", - " g.set_yticklabels(tly, rotation=0)\n", - "\n", - "f.suptitle('MPI run debugging')\n", - "plt.show()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.11" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/fast/runner.py b/fast/runner.py deleted file mode 100644 index 1737a281e9..0000000000 --- a/fast/runner.py +++ /dev/null @@ -1,142 +0,0 @@ -# this file runs a specific benchmarking configuration on archer2 -# and returns the performance data - -from dataclasses import dataclass -import subprocess -import json -from collections import defaultdict -from typing import Iterable - - -@dataclass -class PerfReport: - impl_name: str - bench_name: str - flags: str - env: str - shape: list[int] - ranks: int - cpus: int - - times: list[list[float]] - """ - a list of per-rank execution times - - times[i][k] is the execution time of the k-th rank on the i-th run. - """ - - correctness: list[dict] - - def to_json(self): - return json.dumps({ - 'impl_name': self.impl_name, - 'bench_name': self.bench_name, - 'flags': self.flags, - 'env': self.env, - 'shape': self.shape, - 'ranks': self.ranks, - 'cpus': self.cpus, - 'times': self.times, - 'correctness': self.correctness, - }) - - @staticmethod - def from_json(json_d: str | dict): - if isinstance(json_d, str): - json_d = json.loads(json_d) - return PerfReport(**json_d) - - def report(self): - avg_time = sum(self.times) / len(self.times) - c_nums = [] - if self.correctness: - for correctness_data in self.correctness: - c_nums.append(correctness_data['abs_max_error']) - max_err = '-' if not c_nums else max(c_nums) - - print(f"""Run info: - impl: {self.impl_name} - bench: {self.bench_name} - grid: {self.shape} - time: {avg_time} - max err: {max_err}""") - -def run_benchmark(ranks: int, cpus_per_rank: int, name: str, shape: list[int], flags: str, runs: int = 1, time_limit='00:15:00', env: str = "", qos="standard"): - shape = ' '.join(str(x) for x in shape) - cmd = f"{env} srun -n {ranks} --cpus-per-task {cpus_per_rank} --exclusive --time={time_limit} --partition=standard --qos={qos} --account=d011 --distribution=block:block --hint=nomultithread -u" \ - f" python3 run_benchmark.py {name} {flags} -d {shape} --repeat {runs}" - print(f"running: {cmd}") - pr = subprocess.run(cmd, shell=True, capture_output=True, text=True) - print(pr.stderr) - res = pr.stdout - - reports: list[dict] = [] - - for line in res.splitlines(): - if line[0] != '{': - continue - try: - d = json.loads(line) - reports.append(d) - except json.JSONDecodeError: - pass - - try: - return list(process_records(reports, flags, name, shape, ranks, cpus_per_rank, env)) - except Exception as ex: - print("Error in processing records: ", ex) - print("with output:") - print(res) - - -def get_rank(d: dict): - return d['rank'] -def get_run(d: dict): - return d['run'] -def get_type(d: dict): - return d['type'] -def get_impl(d: dict): - return d['impl'] - -def prune_dict(d: dict, *remove_fields: str): - for f in remove_fields: - d.pop(f, None) - return d - -def process_records(records: list[dict], flags: str, bench: str, shape: list[int], ranks: int, cpus: int, env: str) -> list[PerfReport]: - for run, run_records in sorted(group_by(records, get_run), key=lambda x: x[0]): - kinds = dict( - group_by(run_records, get_type) - ) - - if 'correctness' in kinds: - kinds['correctness'] = [ - prune_dict(d, 'rank', 'run', 'type') - for d in sorted(kinds.get('correctness', []), key=get_rank) - ] - else: - kinds['correctness'] = [] - - assert 'runtime' in kinds, "'runtime' records not present in run output! Something is wrong!" - assert bench == kinds['runtime'][0]['name'], "collected records not for same bench as promised!" - for impl, perf_records in group_by(kinds['runtime'], get_impl): - yield PerfReport( - impl_name=impl, - bench_name=bench, - flags=flags, - env=env, - shape=shape, - ranks=ranks, - cpus=cpus, - times=[ - r['runtime'] for r in sorted(perf_records, key=get_rank) - ], - correctness=kinds['correctness'] - ) - - -def group_by(things: list, key) -> Iterable[list] | dict: - buckets = defaultdict(list) - for thing in things: - buckets[key(thing)].append(thing) - yield from buckets.items() diff --git a/fast/wave2d.py b/fast/wave2d.py deleted file mode 100644 index 3c60dc7c3b..0000000000 --- a/fast/wave2d.py +++ /dev/null @@ -1,158 +0,0 @@ -# Based on the implementation of the Devito acoustic example implementation -# Not using Devito's source injection abstraction -import sys -import numpy as np - -from devito import (TimeFunction, Eq, Operator, solve, norm, - XDSLOperator, configuration) -from examples.seismic import RickerSource -from examples.seismic import Model, TimeAxis, plot_image -from fast.bench_utils import plot_2dfunc -from devito.tools import as_tuple - -import argparse -np.set_printoptions(threshold=np.inf) - - -parser = argparse.ArgumentParser(description='Process arguments.') - -parser.add_argument("-d", "--shape", default=(16, 16), type=int, nargs="+", - help="Number of grid points along each axis") -parser.add_argument("-so", "--space_order", default=4, - type=int, help="Space order of the simulation") -parser.add_argument("-to", "--time_order", default=2, - type=int, help="Time order of the simulation") -parser.add_argument("-nt", "--nt", default=20, - type=int, help="Simulation time in millisecond") -parser.add_argument("-bls", "--blevels", default=1, type=int, nargs="+", - help="Block levels") -parser.add_argument("-plot", "--plot", default=False, type=bool, help="Plot2D") -parser.add_argument("-devito", "--devito", default=False, type=bool, help="Devito run") -parser.add_argument("-xdsl", "--xdsl", default=False, type=bool, help="xDSL run") -args = parser.parse_args() - - -mpiconf = configuration['mpi'] - -# Define a physical size -# nx, ny, nz = args.shape -nt = args.nt - -shape = (args.shape) # Number of grid point (nx, ny, nz) -spacing = as_tuple(10.0 for _ in range(len(shape))) # Grid spacing in m. The domain size is now 1km by 1km -origin = as_tuple(0.0 for _ in range(len(shape))) # What is the location of the top left corner. -# This is necessary to define -# the absolute location of the source and receivers - -# Define a velocity profile. The velocity is in km/s -v = np.empty(shape, dtype=np.float32) -v[:, :] = 1 - -# With the velocity and model size defined, we can create the seismic model that -# encapsulates this properties. We also define the size of the absorbing layer as -# 10 grid points -so = args.space_order -to = args.time_order - -model = Model(vp=v, origin=origin, shape=shape, spacing=spacing, - space_order=so, nbl=0) - -# plot_velocity(model) - -t0 = 0. # Simulation starts a t=0 -tn = nt # Simulation last 1 second (1000 ms) -dt = model.critical_dt # Time step from model grid spacing -print("dt is:", dt) - -time_range = TimeAxis(start=t0, stop=tn, step=dt) - -# The source is positioned at a $20m$ depth and at the middle of the -# $x$ axis ($x_{src}=500m$), -# with a peak wavelet frequency of $10Hz$. -f0 = 0.010 # Source peak frequency is 10Hz (0.010 kHz) -src = RickerSource(name='src', grid=model.grid, f0=f0, - npoint=1, time_range=time_range) - -# First, position source centrally in all dimensions, then set depth -src.coordinates.data[0, :] = np.array(model.domain_size) * .5 - -# We can plot the time signature to see the wavelet -# src.show() - -# Define the wavefield with the size of the model and the time dimension -u = TimeFunction(name="u", grid=model.grid, time_order=to, space_order=so) -# Another one to clone data -u2 = TimeFunction(name="u", grid=model.grid, time_order=to, space_order=so) -ub = TimeFunction(name="ub", grid=model.grid, time_order=to, space_order=so) - -# We can now write the PDE -# pde = model.m * u.dt2 - u.laplace + model.damp * u.dt -# import pdb;pdb.set_trace() -pde = u.dt2 - u.laplace - -stencil = Eq(u.forward, solve(pde, u.forward)) -# stencil - -# Finally we define the source injection and receiver read function to generate -# the corresponding code -# print(time_range) - -print("Init norm:", np.linalg.norm(u.data[:])) -src_term = src.inject(field=u.forward, expr=src * dt**2 / model.m) -op0 = Operator([stencil] + src_term, subs=model.spacing_map, name='SourceDevitoOperator') - -# Run with source and plot -op0.apply(time=time_range.num-1, dt=model.critical_dt) - -if len(shape) == 2: - if args.plot: - plot_2dfunc(u) - -# print("Init Devito linalg norm 0 :", np.linalg.norm(u.data[0])) -# print("Init Devito linalg norm 1 :", np.linalg.norm(u.data[1])) -# print("Init Devito linalg norm 2 :", np.linalg.norm(u.data[2])) -# print("Norm of initial data:", norm(u)) - -configuration['mpi'] = 0 -u2.data[:] = u.data[:] -configuration['mpi'] = mpiconf - -if args.devito: - # Run more with no sources now (Not supported in xdsl) - op1 = Operator([stencil], name='DevitoOperator', opt=('advanced', {'par-tile': (32,4,8)})) - op1.apply(time=time_range.num-1, dt=model.critical_dt) - - configuration['mpi'] = 0 - ub.data[:] = u.data[:] - configuration['mpi'] = mpiconf - - if len(shape) == 2 and args.plot: - plot_2dfunc(u) - - # print("After Operator 1: Devito norm:", norm(u)) - # print("Devito linalg norm 0:", np.linalg.norm(u.data[0])) - # print("Devito linalg norm 1:", np.linalg.norm(u.data[1])) - # print("Devito linalg norm 2:", np.linalg.norm(u.data[2])) - - -if args.xdsl: - # Reset initial data - configuration['mpi'] = 0 - u.data[:] = u2.data[:] - configuration['mpi'] = mpiconf - # v[:, ..., :] = 1 - # print("Reinitialise data: Devito norm:", norm(u)) - # print("XDSL init linalg norm:", np.linalg.norm(u.data[0])) - # print("XDSL init linalg norm:", np.linalg.norm(u.data[1])) - # print("XDSL init linalg norm:", np.linalg.norm(u.data[2])) - - # Run more with no sources now (Not supported in xdsl) - xdslop = XDSLOperator([stencil], name='xDSLOperator') - xdslop.apply(time=time_range.num-1, dt=model.critical_dt) - - if len(shape) == 2 and args.plot: - plot_2dfunc(u) - - print("XDSL output norm 0:", np.linalg.norm(u.data[0]), "vs:", np.linalg.norm(ub.data[0])) - print("XDSL output norm 1:", np.linalg.norm(u.data[1]), "vs:", np.linalg.norm(ub.data[1])) - print("XDSL output norm 2:", np.linalg.norm(u.data[2]), "vs:", np.linalg.norm(ub.data[2])) diff --git a/fast/wave3d.py b/fast/wave3d.py deleted file mode 100644 index 71602ca30f..0000000000 --- a/fast/wave3d.py +++ /dev/null @@ -1,148 +0,0 @@ -# Based on the implementation of the Devito acoustic example implementation -# Not using Devito's source injection abstraction -import sys -import numpy as np -from devito import (TimeFunction, Eq, Operator, solve, norm, - XDSLOperator, configuration) -from examples.seismic import RickerSource -from examples.seismic import Model, TimeAxis -from fast.bench_utils import plot_3dfunc - -from devito.tools import as_tuple - -import argparse -np.set_printoptions(threshold=np.inf) - - -parser = argparse.ArgumentParser(description='Process arguments.') - -parser.add_argument("-d", "--shape", default=(11, 11, 11), type=int, nargs="+", - help="Number of grid points along each axis") -parser.add_argument("-so", "--space_order", default=4, - type=int, help="Space order of the simulation") -parser.add_argument("-to", "--time_order", default=2, - type=int, help="Time order of the simulation") -parser.add_argument("-nt", "--nt", default=200, - type=int, help="Simulation time in millisecond") -parser.add_argument("-bls", "--blevels", default=2, type=int, nargs="+", - help="Block levels") -parser.add_argument("-plot", "--plot", default=False, type=bool, help="Plot3D") -parser.add_argument("-devito", "--devito", default=False, type=bool, help="Devito run") -parser.add_argument("-xdsl", "--xdsl", default=False, type=bool, help="xDSL run") -args = parser.parse_args() - - -mpiconf = configuration['mpi'] - - -# Define a physical size -# nx, ny, nz = args.shape -nt = args.nt - -shape = (args.shape) # Number of grid point (nx, ny, nz) -spacing = as_tuple(10.0 for _ in range(len(shape))) # Grid spacing in m. The domain size is now 1km by 1km -origin = as_tuple(0.0 for _ in range(len(shape))) # What is the location of the top left corner. -# This is necessary to define -# the absolute location of the source and receivers - -# Define a velocity profile. The velocity is in km/s -v = np.empty(shape, dtype=np.float32) -v[:, :, :] = 1 - -# With the velocity and model size defined, we can create the seismic model that -# encapsulates this properties. We also define the size of the absorbing layer as -# 10 grid points -so = args.space_order -to = args.time_order - -model = Model(vp=v, origin=origin, shape=shape, spacing=spacing, - space_order=so, nbl=0) - -# plot_velocity(model) - -t0 = 0. # Simulation starts a t=0 -tn = nt # Simulation last 1 second (1000 ms) -dt = model.critical_dt # Time step from model grid spacing -print("dt is:", dt) - -time_range = TimeAxis(start=t0, stop=tn, step=dt) - -# The source is positioned at a $20m$ depth and at the middle of the -# $x$ axis ($x_{src}=500m$), -# with a peak wavelet frequency of $10Hz$. -f0 = 0.010 # Source peak frequency is 10Hz (0.010 kHz) -src = RickerSource(name='src', grid=model.grid, f0=f0, - npoint=1, time_range=time_range) - -# First, position source centrally in all dimensions, then set depth -src.coordinates.data[0, :] = np.array(model.domain_size) * .5 - -# Define the wavefield with the size of the model and the time dimension -u = TimeFunction(name="u", grid=model.grid, time_order=to, space_order=so) -# Another one to clone data -u2 = TimeFunction(name="u", grid=model.grid, time_order=to, space_order=so) -ub = TimeFunction(name="ub", grid=model.grid, time_order=to, space_order=so) - - -# We can now write the PDE -# pde = model.m * u.dt2 - u.laplace + model.damp * u.dt -# import pdb;pdb.set_trace() -pde = u.dt2 - u.laplace - -stencil = Eq(u.forward, solve(pde, u.forward)) - -src_term = src.inject(field=u.forward, expr=src * dt**2 / model.m) -op0 = Operator([stencil] + src_term, subs=model.spacing_map, name='SourceDevitoOperator') -# Run with source and plot -op0.apply(time=time_range.num-1, dt=model.critical_dt) - - -if len(shape) == 3: - if args.plot: - plot_3dfunc(u) - -# devito_norm = norm(u) -# print("Init linalg norm 0 (inlined) :", norm(u)) -# print("Init linalg norm 0 :", np.linalg.norm(u.data[0])) -# print("Init linalg norm 1 :", np.linalg.norm(u.data[1])) -# print("Init linalg norm 2 :", np.linalg.norm(u.data[2])) -# print("Norm of initial data:", np.linalg.norm(u.data[:])) - -configuration['mpi'] = 0 -u2.data[:] = u.data[:] -configuration['mpi'] = mpiconf - -# Run more with no sources now (Not supported in xdsl) -op1 = Operator([stencil], name='DevitoOperator', opt=('advanced', {'par-tile': (32,4,8)})) -op1.apply(time=time_range.num-1, dt=model.critical_dt) - -configuration['mpi'] = 0 -ub.data[:] = u.data[:] -configuration['mpi'] = mpiconf - -if len(shape) == 3: - if args.plot: - plot_3dfunc(u) - -# print("After Operator 1: Devito norm:", np.linalg.norm(u.data[:])) -#print("Devito norm 0:", np.linalg.norm(u.data[0])) -#print("Devito norm 1:", np.linalg.norm(u.data[1])) -#print("Devito norm 2:", np.linalg.norm(u.data[2])) - -# Reset initial data -configuration['mpi'] = 0 -u.data[:] = u2.data[:] -configuration['mpi'] = mpiconf - -# print("Reinitialise data for XDSL:", np.linalg.norm(u.data[:])) -# print("Init XDSL linalg norm 0:", np.linalg.norm(u.data[0])) -# print("Init XDSL linalg norm 1:", np.linalg.norm(u.data[1])) -# print("Init XDSL linalg norm 2:", np.linalg.norm(u.data[2])) - -# Run more with no sources now (Not supported in xdsl) -xdslop = XDSLOperator([stencil], name='XDSLOperator') -xdslop.apply(time=time_range.num-1, dt=model.critical_dt) - -print("XDSL output norm 0:", np.linalg.norm(u.data[0]), "vs:", np.linalg.norm(ub.data[0])) -print("XDSL output norm 1:", np.linalg.norm(u.data[1]), "vs:", np.linalg.norm(ub.data[1])) -print("XDSL output norm 2:", np.linalg.norm(u.data[2]), "vs:", np.linalg.norm(ub.data[2])) diff --git a/fast/wave_dat2.npy b/fast/wave_dat2.npy deleted file mode 100644 index 22e536f687..0000000000 Binary files a/fast/wave_dat2.npy and /dev/null differ