From ffc3f575cc7af42d0a4cac073da154a39aff77cf Mon Sep 17 00:00:00 2001 From: Sansriti Ranjan Date: Fri, 19 May 2023 11:38:19 -0400 Subject: [PATCH 1/5] Trial for pull request using squash --- pySDC/implementations/hooks/log_errors.py | 33 +- pySDC/implementations/hooks/log_solution.py | 6 +- .../problem_classes/AllenCahn_MPIFFT.py | 71 +++- pySDC/projects/compression/CRAM_Manager.py | 184 ++++++++ .../projects/compression/allencahn_example.py | 107 +++++ pySDC/projects/compression/compressed_mesh.py | 392 ++++++++++++++++++ .../compression/compressed_problems.py | 20 + .../compression_convergence_controller.py | 63 ++- pySDC/projects/compression/heat_example.py | 110 +++++ .../compression/log_datatype_creations.py | 32 ++ pySDC/projects/compression/order.py | 145 ++++--- .../test_compression/test_manager.py | 71 ++++ .../test_compression/test_proof_of_concept.py | 29 +- 13 files changed, 1160 insertions(+), 103 deletions(-) create mode 100644 pySDC/projects/compression/CRAM_Manager.py create mode 100644 pySDC/projects/compression/allencahn_example.py create mode 100644 pySDC/projects/compression/compressed_mesh.py create mode 100644 pySDC/projects/compression/compressed_problems.py create mode 100644 pySDC/projects/compression/heat_example.py create mode 100644 pySDC/projects/compression/log_datatype_creations.py create mode 100644 pySDC/tests/test_projects/test_compression/test_manager.py diff --git a/pySDC/implementations/hooks/log_errors.py b/pySDC/implementations/hooks/log_errors.py index 963ba8d3f0..d5833c3e7c 100644 --- a/pySDC/implementations/hooks/log_errors.py +++ b/pySDC/implementations/hooks/log_errors.py @@ -12,7 +12,7 @@ class LogError(hooks): to work, be it a reference solution or something analytical. """ - def log_global_error(self, step, level_number, suffix=''): + def log_global_error(self, step, level_number, suffix=""): """ Function to add the global error to the stats @@ -36,7 +36,7 @@ def log_global_error(self, step, level_number, suffix=''): level=L.level_index, iter=step.status.iter, sweep=L.status.sweep, - type=f'e_global{suffix}', + type=f"e_global{suffix}", value=abs(u_ref - L.uend), ) self.add_to_stats( @@ -45,11 +45,11 @@ def log_global_error(self, step, level_number, suffix=''): level=L.level_index, iter=step.status.iter, sweep=L.status.sweep, - type=f'e_global_rel{suffix}', + type=f"e_global_rel{suffix}", value=abs((u_ref - L.uend / u_ref)), ) - def log_local_error(self, step, level_number, suffix=''): + def log_local_error(self, step, level_number, suffix=""): """ Function to add the local error to the stats @@ -71,15 +71,18 @@ def log_local_error(self, step, level_number, suffix=''): level=L.level_index, iter=step.status.iter, sweep=L.status.sweep, - type=f'e_local{suffix}', - value=abs(L.prob.u_exact(t=L.time + L.dt, u_init=L.u[0] * 1.0, t_init=L.time) - L.uend), + type=f"e_local{suffix}", + value=abs( + L.prob.u_exact(t=L.time + L.dt, u_init=L.u[0] * 1.0, t_init=L.time) + - L.uend + ), ) class LogGlobalErrorPostStep(LogError): def post_step(self, step, level_number): super().post_step(step, level_number) - self.log_global_error(step, level_number, '_post_step') + self.log_global_error(step, level_number, "_post_step") class LogGlobalErrorPostRun(hooks): @@ -120,7 +123,7 @@ def post_step(self, step, level_number): """ super().post_step(step, level_number) self.t_last_solution = step.levels[0].time + step.levels[0].dt - self.num_restarts = step.status.get('restarts_in_a_row', 0) + self.num_restarts = step.status.get("restarts_in_a_row", 0) def post_run(self, step, level_number): """ @@ -142,7 +145,9 @@ def post_run(self, step, level_number): u_num = self.get_final_solution(L) u_ref = L.prob.u_exact(t=self.t_last_solution) - self.logger.info(f'Finished with a global error of e={abs(u_num-u_ref):.2e}') + self.logger.info( + f"Finished with a global error of e={abs(u_num-u_ref):.2e}" + ) self.add_to_stats( process=step.status.slot, @@ -150,7 +155,7 @@ def post_run(self, step, level_number): level=L.level_index, iter=step.status.iter, sweep=L.status.sweep, - type='e_global_post_run', + type="e_global_post_run", value=abs(u_num - u_ref), ) self.add_to_stats( @@ -159,8 +164,8 @@ def post_run(self, step, level_number): level=L.level_index, iter=step.status.iter, sweep=L.status.sweep, - type='e_global_rel_post_run', - value=abs((u_num - u_ref) / u_ref), + type="e_global_rel_post_run", + value=abs(u_num - u_ref) / abs(u_ref), ) def get_final_solution(self, lvl): @@ -205,7 +210,7 @@ class LogLocalErrorPostStep(LogError): def post_step(self, step, level_number): super().post_step(step, level_number) - self.log_local_error(step, level_number, suffix='_post_step') + self.log_local_error(step, level_number, suffix="_post_step") class LogLocalErrorPostIter(LogError): @@ -224,4 +229,4 @@ def post_iteration(self, step, level_number): """ super().post_iteration(step, level_number) - self.log_local_error(step, level_number, suffix='_post_iteration') + self.log_local_error(step, level_number, suffix="_post_iteration") diff --git a/pySDC/implementations/hooks/log_solution.py b/pySDC/implementations/hooks/log_solution.py index f6a1980558..b1d6f8f834 100644 --- a/pySDC/implementations/hooks/log_solution.py +++ b/pySDC/implementations/hooks/log_solution.py @@ -28,8 +28,8 @@ def post_step(self, step, level_number): level=L.level_index, iter=step.status.iter, sweep=L.status.sweep, - type='u', - value=L.uend, + type="u", + value=L.uend[:], ) @@ -60,6 +60,6 @@ def post_iteration(self, step, level_number): level=L.level_index, iter=step.status.iter, sweep=L.status.sweep, - type='u', + type="u", value=L.uend, ) diff --git a/pySDC/implementations/problem_classes/AllenCahn_MPIFFT.py b/pySDC/implementations/problem_classes/AllenCahn_MPIFFT.py index 747048a1db..948e6db285 100644 --- a/pySDC/implementations/problem_classes/AllenCahn_MPIFFT.py +++ b/pySDC/implementations/problem_classes/AllenCahn_MPIFFT.py @@ -26,7 +26,9 @@ class allencahn_imex(ptype): dtype_u = mesh dtype_f = imex_mesh - def __init__(self, nvars, eps, radius, spectral, dw=0.0, L=1.0, init_type='circle', comm=None): + def __init__( + self, nvars, eps, radius, spectral, dw=0.0, L=1.0, init_type="circle", comm=None + ): """ Initialization routine @@ -36,7 +38,7 @@ def __init__(self, nvars, eps, radius, spectral, dw=0.0, L=1.0, init_type='circl dtype_f: fft data type wuth implicit and explicit parts (will be passed to parent class) """ if not (isinstance(nvars, tuple) and len(nvars) > 1): - raise ProblemError('Need at least two dimensions') + raise ProblemError("Need at least two dimensions") # Creating FFT structure ndim = len(nvars) @@ -49,7 +51,16 @@ def __init__(self, nvars, eps, radius, spectral, dw=0.0, L=1.0, init_type='circl # invoke super init, passing the communicator and the local dimensions as init super().__init__(init=(tmp_u.shape, comm, tmp_u.dtype)) self._makeAttributeAndRegister( - 'nvars', 'eps', 'radius', 'spectral', 'dw', 'L', 'init_type', 'comm', localVars=locals(), readOnly=True + "nvars", + "eps", + "radius", + "spectral", + "dw", + "L", + "init_type", + "comm", + localVars=locals(), + readOnly=True, ) L = np.array([self.L] * ndim, dtype=float) @@ -67,7 +78,7 @@ def __init__(self, nvars, eps, radius, spectral, dw=0.0, L=1.0, init_type='circl k = [np.fft.fftfreq(n, 1.0 / n).astype(int) for n in N[:-1]] k.append(np.fft.rfftfreq(N[-1], 1.0 / N[-1]).astype(int)) K = [ki[si] for ki, si in zip(k, s)] - Ks = np.meshgrid(*K, indexing='ij', sparse=True) + Ks = np.meshgrid(*K, indexing="ij", sparse=True) Lp = 2 * np.pi / L for i in range(ndim): Ks[i] = (Ks[i] * Lp[i]).astype(float) @@ -98,7 +109,9 @@ def eval_f(self, u, t): if self.eps > 0: tmp = self.fft.backward(u) - tmpf = -2.0 / self.eps**2 * tmp * (1.0 - tmp) * (1.0 - 2.0 * tmp) - 6.0 * self.dw * tmp * (1.0 - tmp) + tmpf = -2.0 / self.eps**2 * tmp * (1.0 - tmp) * ( + 1.0 - 2.0 * tmp + ) - 6.0 * self.dw * tmp * (1.0 - tmp) f.expl[:] = self.fft.forward(tmpf) else: @@ -107,7 +120,9 @@ def eval_f(self, u, t): f.impl[:] = self.fft.backward(lap_u_hat, f.impl) if self.eps > 0: - f.expl = -2.0 / self.eps**2 * u * (1.0 - u) * (1.0 - 2.0 * u) - 6.0 * self.dw * u * (1.0 - u) + f.expl = -2.0 / self.eps**2 * u * (1.0 - u) * ( + 1.0 - 2.0 * u + ) - 6.0 * self.dw * u * (1.0 - u) return f @@ -130,7 +145,7 @@ def solve_system(self, rhs, factor, u0, t): else: me = self.dtype_u(self.init) - rhs_hat = self.fft.forward(rhs) + rhs_hat = self.fft.forward(rhs[:]) rhs_hat /= 1.0 + factor * self.K2 me[:] = self.fft.backward(rhs_hat) @@ -147,32 +162,46 @@ def u_exact(self, t): dtype_u: exact solution """ - assert t == 0, 'ERROR: u_exact only valid for t=0' + assert t == 0, "ERROR: u_exact only valid for t=0" me = self.dtype_u(self.init, val=0.0) - if self.init_type == 'circle': + if self.init_type == "circle": r2 = (self.X[0] - 0.5) ** 2 + (self.X[1] - 0.5) ** 2 if self.spectral: - tmp = 0.5 * (1.0 + np.tanh((self.radius - np.sqrt(r2)) / (np.sqrt(2) * self.eps))) + tmp = 0.5 * ( + 1.0 + np.tanh((self.radius - np.sqrt(r2)) / (np.sqrt(2) * self.eps)) + ) me[:] = self.fft.forward(tmp) else: - me[:] = 0.5 * (1.0 + np.tanh((self.radius - np.sqrt(r2)) / (np.sqrt(2) * self.eps))) - elif self.init_type == 'circle_rand': - ndim = len(me.shape) + me[:] = 0.5 * ( + 1.0 + np.tanh((self.radius - np.sqrt(r2)) / (np.sqrt(2) * self.eps)) + ) + elif self.init_type == "circle_rand": + ndim = len(me[:].shape) L = int(self.L) # get random radii for circles/spheres np.random.seed(1) lbound = 3.0 * self.eps ubound = 0.5 - self.eps - rand_radii = (ubound - lbound) * np.random.random_sample(size=tuple([L] * ndim)) + lbound + rand_radii = (ubound - lbound) * np.random.random_sample( + size=tuple([L] * ndim) + ) + lbound # distribute circles/spheres tmp = newDistArray(self.fft, False) if ndim == 2: for i in range(0, L): for j in range(0, L): # build radius - r2 = (self.X[0] + i - L + 0.5) ** 2 + (self.X[1] + j - L + 0.5) ** 2 + r2 = (self.X[0] + i - L + 0.5) ** 2 + ( + self.X[1] + j - L + 0.5 + ) ** 2 # add this blob, shifted by 1 to avoid issues with adding up negative contributions - tmp += np.tanh((rand_radii[i, j] - np.sqrt(r2)) / (np.sqrt(2) * self.eps)) + 1 + tmp += ( + np.tanh( + (rand_radii[i, j] - np.sqrt(r2)) + / (np.sqrt(2) * self.eps) + ) + + 1 + ) # normalize to [0,1] tmp *= 0.5 assert np.all(tmp <= 1.0) @@ -181,7 +210,9 @@ def u_exact(self, t): else: me[:] = tmp[:] else: - raise NotImplementedError('type of initial value not implemented, got %s' % self.init_type) + raise NotImplementedError( + "type of initial value not implemented, got %s" % self.init_type + ) return me @@ -241,7 +272,7 @@ def eval_f(self, u, t): f.expl[:] = self.fft.forward(tmpf) else: - u_hat = self.fft.forward(u) + u_hat = self.fft.forward(u[:]) lap_u_hat = -self.K2 * u_hat f.impl[:] = self.fft.backward(lap_u_hat, f.impl) @@ -249,14 +280,14 @@ def eval_f(self, u, t): f.expl = -2.0 / self.eps**2 * u * (1.0 - u) * (1.0 - 2.0 * u) # build sum over RHS without driving force - Rt_local = float(np.sum(f.impl + f.expl)) + Rt_local = float(np.sum(f.impl[:] + f.expl[:])) if self.comm is not None: Rt_global = self.comm.allreduce(sendobj=Rt_local, op=MPI.SUM) else: Rt_global = Rt_local # build sum over driving force term - Ht_local = float(np.sum(6.0 * u * (1.0 - u))) + Ht_local = float(np.sum(6.0 * u[:] * (1.0 - u[:]))) if self.comm is not None: Ht_global = self.comm.allreduce(sendobj=Ht_local, op=MPI.SUM) else: diff --git a/pySDC/projects/compression/CRAM_Manager.py b/pySDC/projects/compression/CRAM_Manager.py new file mode 100644 index 0000000000..a829f7f66c --- /dev/null +++ b/pySDC/projects/compression/CRAM_Manager.py @@ -0,0 +1,184 @@ +# python class that calls c functions to handle compression/decompression +import numpy as np + +np.bool = np.bool_ +import libpressio +from pySDC.implementations.datatype_classes.mesh import mesh + + +class CRAM_Manager: + # constructor + def __init__(self, errBoundMode="ABS", compType="sz3", errBound=1e-5): + # print("constructor called!") + # if self.init = 0 + self.errBoundMode = errBoundMode + self.errBound = errBound + self.compType = compType + self.mem_map = {} + self.cache = {} + self.max_cache_size = 30 + # self.init = 1 + self.name = 0 # TODO: update registration to return name + + # destructor + def __del__(self): + pass + + # numVectors is M + def registerVar( + self, + varName, + shape, + dtype=np.dtype("float64"), + numVectors=1, + errBoundMode=None, + compType=None, + errBound=None, + ): + if varName not in self.mem_map: + # print("Register: ", varName, "-", shape, len(self.mem_map.keys())) + compressor = libpressio.PressioCompressor.from_config( + self.generate_compressor_config(compType, errBoundMode, errBound) + ) + + self.mem_map[varName] = [ + compressor, + [compressor.encode(np.ones(shape)) for i in range(numVectors)], + shape, + ] # TODO finish + + def remove(self, name, index): + self.cache.pop(name + "_" + str(index), None) + self.mem_map.pop(name, None) + + def compress( + self, data, varName, index, errBoundMode="ABS", compType="sz3", errBound=None + ): + # print("Cprss: ", varName, index) + # print("Array: ", data) + # print("Error bound: ",errBound) + if errBound is not None: + compressor = libpressio.PressioCompressor.from_config( + self.generate_compressor_config(compType, errBoundMode, errBound) + ) + # cfg = compressor.get_config() + # print(errBound) + # cfg['compressor_config']['pressio:abs'] = errBound + + # compressor.set_config(cfg) + self.mem_map[varName][0] = compressor + else: + compressor = self.mem_map[varName][0] + # print(compressor.get_config()['compressor_id']) + # print(compressor.get_config()['compressor_config']) + self.mem_map[varName][1][index] = compressor.encode(data) + self.cache.pop(self.cacheName(varName, index), None) + + def cacheName(self, varName, index): + return varName + "_" + str(index) + + def decompress(self, varName, index, compType=0): + # print("Decprss: ", varName, index) + combineName = self.cacheName(varName, index) + if combineName not in self.cache: + compressor = self.mem_map[varName][0] + comp_data = self.mem_map[varName][1][index] + decomp_data = np.zeros(self.mem_map[varName][2]) + # if comp_data != None: + tmp = compressor.decode(comp_data, decomp_data) + + if ( + len(self.cache) + 1 > self.max_cache_size + ): # TODO: Add LRU replacement policy + k = list(self.cache.keys())[0] + self.cache.pop(k) + self.cache[combineName] = tmp + return tmp + + # else: + # tmp = decomp_data + + tmp_mesh = mesh(self.mem_map[varName][2]) + tmp_mesh[:] = tmp + + else: + # print ("Found in Cache") + return self.cache[combineName] + + def set_global_compressor_config( + self, compType=None, errBoundMode=None, errBound=None + ): + self.compType = self.compType if compType is None else compType + self.errBoundMode = self.errBoundMode if errBoundMode is None else errBoundMode + self.errBound = self.errBound if errBound is None else errBound + for k in self.mem_map: + self.mem_map[k][0] = libpressio.PressioCompressor.from_config( + self.generate_compressor_config( + self.compType, self.errBoundMode, self.errBound + ) + ) + + def generate_compressor_config( + self, compType=None, errBoundMode=None, errBound=None + ): + compType = self.compType if compType is None else compType + errBoundMode = self.errBoundMode if errBoundMode is None else errBoundMode + errBound = self.errBound if errBound is None else errBound + # print('Error bound: ',errBound) + return { + # configure which compressor to use + "compressor_id": compType, + # configure the set of metrics to be gathered + "early_config": { + "pressio:metric": "composite", + "composite:plugins": ["time", "size", "error_stat"], + }, + # configure SZ + "compressor_config": { + "pressio:abs": errBound, + }, + } + + def __str__(self): + # print values in the dictionary + s = "Memory\n" + for k in self.mem_map.keys(): + s += k + str(self.mem_map[k]) + "\n" + + s += "\nCache\n" + for k in self.cache.keys(): + s += k + str(self.cache[k]) + "\n" + + return s + + # def printStats(self, varName, index=0): + # print(" ") #for readability + # sz_class.sz_printVarInfo(varName) + + def getStats(self, varName, index=0): + compressor = self.mem_map[varName][0] + return compressor.get_metrics() + + +if __name__ == "__main__": + arr = np.random.rand(100, 100) + # declare global instance of memory + memory = CRAM_Manager(errBoundMode="ABS", compType="sz3", errBound=1e-5) + + memory.registerVar( + "cat", + arr.shape, + dtype=np.dtype("float64"), + numVectors=1, + errBoundMode="ABS", + compType="sz3", + errBound=0.1, + ) + memory.compress(arr, "cat", 0) + result = memory.decompress("cat", 0, shape=arr.shape) + print(arr) + print("\n") + print(result) + print("\n") + error = arr - result + print(error) diff --git a/pySDC/projects/compression/allencahn_example.py b/pySDC/projects/compression/allencahn_example.py new file mode 100644 index 0000000000..d28991ddae --- /dev/null +++ b/pySDC/projects/compression/allencahn_example.py @@ -0,0 +1,107 @@ +from pySDC.implementations.problem_classes.HeatEquation_ND_FD import heatNd_forced +from pySDC.implementations.sweeper_classes.imex_1st_order import imex_1st_order +from pySDC.implementations.controller_classes.controller_MPI import controller_MPI +from pySDC.implementations.controller_classes.controller_nonMPI import controller_nonMPI +from pySDC.helpers.stats_helper import get_sorted +from mpi4py import MPI +from pySDC.implementations.hooks.log_errors import LogGlobalErrorPostRun +from pySDC.implementations.hooks.log_solution import LogSolution +from pySDC.projects.compression.compressed_problems import ( + AllenCahn_MPIFFT_Compressed, + allencahn_imex_timeforcing, +) +from pySDC.projects.compression.log_datatype_creations import LogDatatypeCreations +from pySDC.projects.compression.compression_convergence_controller import ( + Compression_Conv_Controller, +) + + +def run_AC(Tend=1): + # setup communicator + # comm = MPI.COMM_WORLD if comm is None else comm + # initialize problem parameters + problem_params = {} + problem_params["eps"] = 0.04 + problem_params["radius"] = 0.25 + problem_params["spectral"] = False + problem_params["dw"] = 0.0 + problem_params["L"] = 10 + problem_params["init_type"] = "circle_rand" + problem_params["nvars"] = (128, 128) # Have to be the same, Nx = Ny + problem_params["comm"] = MPI.COMM_SELF + + convergence_controllers = {} + convergence_controllers[Compression_Conv_Controller] = {"errBound": 1e-9} + + # initialize level parameters + level_params = {} + level_params["restol"] = 5e-07 + level_params["dt"] = 1e-03 + level_params["nsweeps"] = 1 + + # initialize sweeper parameters + sweeper_params = {} + sweeper_params["node_type"] = "LEGENDRE" + sweeper_params["quad_type"] = "RADAU-RIGHT" + sweeper_params["QI"] = ["IE"] + sweeper_params["QE"] = ["PIC"] + sweeper_params["num_nodes"] = 3 + sweeper_params["initial_guess"] = "spread" + + # initialize step parameters + step_params = {} + step_params["maxiter"] = 50 + + # initialize controller parameters + controller_params = {} + controller_params["logger_level"] = 15 + controller_params["hook_class"] = [ + LogSolution, + # LogDatatypeCreations, + ] + + # fill description dictionary for easy step instantiation + description = {} + # description['problem_class'] = AllenCahn_MPIFFT_Compressed + description["problem_class"] = allencahn_imex_timeforcing + description["problem_params"] = problem_params + description["sweeper_class"] = imex_1st_order + description["sweeper_params"] = sweeper_params + description["level_params"] = level_params + description["step_params"] = step_params + description["convergence_controllers"] = convergence_controllers + + # instantiate controller + controller = controller_nonMPI( + controller_params=controller_params, description=description, num_procs=1 + ) + + # get initial values on finest level + P = controller.MS[0].levels[0].prob + uinit = P.u_exact(0.0) + + # call main function to get things done... + uend, stats = controller.run(u0=uinit, t0=0.0, Tend=Tend) + + return stats + + +def main(): + from pySDC.helpers.stats_helper import get_list_of_types, sort_stats, filter_stats + + stats = run_AC(Tend=0.002) + print(get_list_of_types(stats)) + # print("filter_stats", filter_stats(stats, type="u")) + # print("sort_stats", sort_stats(filter_stats(stats, type="u"), sortby="time")) + u = get_sorted(stats, type="u") + # print(u) + import matplotlib.pyplot as plt + + # plt.plot([me[0] for me in u], [me[1] for me in u]) + # plt.show() + plt.imshow(u[-1][1]) + plt.savefig("result_AC") + + +if __name__ == "__main__": + main() diff --git a/pySDC/projects/compression/compressed_mesh.py b/pySDC/projects/compression/compressed_mesh.py new file mode 100644 index 0000000000..f9769a5aa1 --- /dev/null +++ b/pySDC/projects/compression/compressed_mesh.py @@ -0,0 +1,392 @@ +# from pySDC.implementations.datatype_classes.compressed_mesh import compressed_mesh +import numpy as np +from pySDC.projects.compression.CRAM_Manager import CRAM_Manager +from pySDC.core.Errors import DataError + + +class compressed_mesh(object): + """ + Mesh data type with arbitrary dimensions + + This data type can be used whenever structured data with a single unknown per point in space is required + + Attributes: + values (np.ndarray): contains the ndarray of the values + """ + + manager = CRAM_Manager("ABS", "sz3", 1e-5) + + def __init__(self, init=None, val=0.0): + """ + Initialization routine + + Args: + init: can either be a tuple (one int per dimension) or a number (if only one dimension is requested) + or another mesh object + val: initial value (default: None) + Raises: + DataError: if init is none of the types above + """ + self.name = str(self.manager.name + 1) + self.manager.name += 1 + # if init is another mesh, do a copy (init by copy) + if isinstance(init, compressed_mesh): + values = self.manager.decompress( + init.name, 0 + ) # TODO: Modify manager to copy compressed buffer + self.manager.registerVar( + self.name, + values.shape, + values.dtype, + # numVectors=1, + # errBoundMode="ABS", + # compType="sz3", + # errBound=self.manager.errBound, + ) + self.manager.compress(values.copy(), self.name, 0) + # if init is a number or a tuple of numbers, create mesh object with val as initial value + elif isinstance(init, tuple) or isinstance(init, int): + self.manager.registerVar( + self.name, + init[0], + init[2], + # numVectors=1, + # errBoundMode="ABS", + # compType="sz3", + # errBound=self.manager.errBound, + ) + self.manager.compress( + np.full(init[0], fill_value=val, dtype=np.dtype("float64")), + self.name, + 0, + ) + # something is wrong, if none of the ones above hit + else: + raise DataError( + "something went wrong during %s initialization" % type(self) + ) + + def __del__(self): + # print('Delete'+' ' +self.name) + self.manager.remove(self.name, 0) + + def __add__(self, other): + """ + Overloading the addition operator for mesh types + + Args: + other (mesh.mesh): mesh object to be added + Raises: + DataError: if other is not a mesh object + Returns: + mesh.mesh: sum of caller and other values (self+other) + """ + + me = compressed_mesh(self) + values = self.manager.decompress(self.name, 0) + + if isinstance(other, compressed_mesh): + # always create new mesh, since otherwise c = a - b changes a as well! + ov = self.manager.decompress(other.name, 0) + # else: + # raise DataError( + # "Type error: cannot subtract %s from %s" % (type(other), type(self)) + # ) + else: + ov = other + self.manager.compress(values + ov, me.name, 0) + return me + + def __radd__(self, other): + return self.__add__(other) + + def __sub__(self, other): + """ + Overloading the subtraction operator for mesh types + + Args: + other (mesh.mesh): mesh object to be subtracted + Raises: + DataError: if other is not a mesh object + Returns: + mesh.mesh: differences between caller and other values (self-other) + """ + me = compressed_mesh(self) + values = self.manager.decompress(self.name, 0) + + if isinstance(other, compressed_mesh): + # always create new mesh, since otherwise c = a - b changes a as well! + ov = self.manager.decompress(other.name, 0) + # else: + # raise DataError( + # "Type error: cannot subtract %s from %s" % (type(other), type(self)) + # ) + else: + ov = other + self.manager.compress(values - ov, me.name, 0) + return me + + def __rsub__(self, other): + me = compressed_mesh(self) + values = self.manager.decompress(self.name, 0) + + if isinstance(other, compressed_mesh): + # always create new mesh, since otherwise c = a - b changes a as well! + ov = self.manager.decompress(other.name, 0) + # else: + # raise DataError( + # "Type error: cannot subtract %s from %s" % (type(other), type(self)) + # ) + else: + ov = other + self.manager.compress(ov - values, me.name, 0) + return me + + def __rmul__(self, other): + """ + Overloading the right multiply by factor operator for mesh types + + Args: + other (float): factor + Raises: + DataError: is other is not a float + Returns: + mesh.mesh: copy of original values scaled by factor + """ + me = compressed_mesh(self) + values = self.manager.decompress(self.name, 0) + + if isinstance(other, compressed_mesh): + # always create new mesh, since otherwise c = a - b changes a as well! + ov = self.manager.decompress(other.name, 0) + # else: + # raise DataError( + # "Type error: cannot subtract %s from %s" % (type(other), type(self)) + # ) + else: + ov = other + self.manager.compress(ov * values, me.name, 0) + return me + + def __mul__(self, other): + return self.__rmul__(other) + + def __abs__(self): + """ + Overloading the abs operator for mesh types + + Returns: + float: absolute maximum of all mesh values + """ + + # take absolute values of the mesh values + values = self.manager.decompress(self.name, 0) + absval = abs(values) + + # return maximum + return np.amax(absval) + + def __setitem__(self, key, newvalue): + # print("SET: ", key, newvalue) + if type(newvalue) == type(self): # Assigning compressed mesh + arr_temp = self.manager.decompress(newvalue.name, 0) + self.manager.compress(arr_temp, self.name, 0) + else: + array = self.manager.decompress(self.name, 0) + array.__setitem__(key, newvalue) + self.manager.compress(array, self.name, 0) + + def __getitem__(self, key): + array = self.manager.decompress(self.name, 0) + return array.__getitem__(key) + + def __str__(self): + return str(self[:]) + + def flatten(self): + return self.manager.decompress(self.name, 0).flatten() + + +''' + def apply_mat(self, A): + """ + Matrix multiplication operator + + Args: + A: a matrix + + Returns: + mesh.mesh: component multiplied by the matrix A + """ + if not A.shape[1] == self.values.shape[0]: + raise DataError("ERROR: cannot apply operator %s to %s" % (A.shape[1], self)) + + me = mesh(A.shape[0]) + me.values = A.dot(self.values) + + return me + + def isend(self, dest=None, tag=None, comm=None): + """ + Routine for sending data forward in time (non-blocking) + + Args: + dest (int): target rank + tag (int): communication tag + comm: communicator + + Returns: + request handle + """ + return comm.Issend(self.values[:], dest=dest, tag=tag) + + def irecv(self, source=None, tag=None, comm=None): + """ + Routine for receiving in time + + Args: + source (int): source rank + tag (int): communication tag + comm: communicator + + Returns: + None + """ + return comm.Irecv(self.values[:], source=source, tag=tag) + + def bcast(self, root=None, comm=None): + """ + Routine for broadcasting values + + Args: + root (int): process with value to broadcast + comm: communicator + + Returns: + broadcasted values + """ + return comm.bcast(self, root=root) +''' + + +class imex_mesh_compressed(object): + """ + RHS data type for meshes with implicit and explicit components + + This data type can be used to have RHS with 2 components (here implicit and explicit) + + Attributes: + impl (mesh.mesh): implicit part + expl (mesh.mesh): explicit part + """ + + def __init__(self, init, val=0.0): + """ + Initialization routine + + Args: + init: can either be a tuple (one int per dimension) or a number (if only one dimension is requested) + or another rhs_imex_mesh object + val (float): an initial number (default: 0.0) + Raises: + DataError: if init is none of the types above + """ + + # if init is another rhs_imex_mesh, do a copy (init by copy) + if isinstance(init, type(self)): + self.impl = compressed_mesh(init.impl) + self.expl = compressed_mesh(init.expl) + # if init is a number or a tuple of numbers, create compressed_mesh object with None as initial value + elif isinstance(init, tuple) or isinstance(init, int): + self.impl = compressed_mesh(init, val=val) + self.expl = compressed_mesh(init, val=val) + # something is wrong, if none of the ones above hit + else: + raise DataError( + "something went wrong during %s initialization" % type(self) + ) + + # def __sub__(self, other): + # """ + # Overloading the subtraction operator for rhs types + + # Args: + # other (compressed_mesh.rhs_imex_compressed_mesh): rhs object to be subtracted + # Raises: + # DataError: if other is not a rhs object + # Returns: + # compressed_mesh.rhs_imex_compressed_mesh: differences between caller and other values (self-other) + # """ + + # if isinstance(other, rhs_imex_compressed_mesh): + # # always create new rhs_imex_compressed_mesh, since otherwise c = a - b changes a as well! + # me = rhs_imex_compressed_mesh(self) + # me.impl.values = self.impl.values - other.impl.values + # me.expl.values = self.expl.values - other.expl.values + # return me + # else: + # raise DataError("Type error: cannot subtract %s from %s" % (type(other), type(self))) + + # def __add__(self, other): + # """ + # Overloading the addition operator for rhs types + + # Args: + # other (compressed_mesh.rhs_imex_compressed_mesh): rhs object to be added + # Raises: + # DataError: if other is not a rhs object + # Returns: + # compressed_mesh.rhs_imex_compressed_mesh: sum of caller and other values (self-other) + # """ + + # if isinstance(other, rhs_imex_compressed_mesh): + # # always create new rhs_imex_compressed_mesh, since otherwise c = a + b changes a as well! + # me = rhs_imex_compressed_mesh(self) + # me.impl.values = self.impl.values + other.impl.values + # me.expl.values = self.expl.values + other.expl.values + # return me + # else: + # raise DataError("Type error: cannot add %s to %s" % (type(other), type(self))) + + # def __rmul__(self, other): + # """ + # Overloading the right multiply by factor operator for compressed_mesh types + + # Args: + # other (float): factor + # Raises: + # DataError: is other is not a float + # Returns: + # compressed_mesh.rhs_imex_compressed_mesh: copy of original values scaled by factor + # """ + + # if isinstance(other, float): + # # always create new rhs_imex_compressed_mesh + # me = rhs_imex_compressed_mesh(self) + # me.impl.values = other * self.impl.values + # me.expl.values = other * self.expl.values + # return me + # else: + # raise DataError("Type error: cannot multiply %s to %s" % (type(other), type(self))) + + # def apply_mat(self, A): + # """ + # Matrix multiplication operator + + # Args: + # A: a matrix + + # Returns: + # compressed_mesh.rhs_imex_compressed_mesh: each component multiplied by the matrix A + # """ + + # if not A.shape[1] == self.impl.values.shape[0]: + # raise DataError("ERROR: cannot apply operator %s to %s" % (A, self.impl)) + # if not A.shape[1] == self.expl.values.shape[0]: + # raise DataError("ERROR: cannot apply operator %s to %s" % (A, self.expl)) + + # me = rhs_imex_compressed_mesh(A.shape[1]) + # me.impl.values = A.dot(self.impl.values) + # me.expl.values = A.dot(self.expl.values) + + # return me diff --git a/pySDC/projects/compression/compressed_problems.py b/pySDC/projects/compression/compressed_problems.py new file mode 100644 index 0000000000..df16bc1256 --- /dev/null +++ b/pySDC/projects/compression/compressed_problems.py @@ -0,0 +1,20 @@ +from pySDC.implementations.problem_classes.HeatEquation_ND_FD import heatNd_unforced +from pySDC.implementations.problem_classes.HeatEquation_ND_FD import heatNd_forced +from pySDC.implementations.problem_classes.AllenCahn_MPIFFT import ( + allencahn_imex_timeforcing, +) + +from pySDC.projects.compression.compressed_mesh import ( + compressed_mesh, + imex_mesh_compressed, +) + + +class heat_ND_compressed(heatNd_forced): + dtype_f = imex_mesh_compressed + dtype_u = compressed_mesh + + +class AllenCahn_MPIFFT_Compressed(allencahn_imex_timeforcing): + dtype_f = imex_mesh_compressed + dtype_u = compressed_mesh diff --git a/pySDC/projects/compression/compression_convergence_controller.py b/pySDC/projects/compression/compression_convergence_controller.py index 8ea952a991..b84d27f377 100644 --- a/pySDC/projects/compression/compression_convergence_controller.py +++ b/pySDC/projects/compression/compression_convergence_controller.py @@ -1,4 +1,5 @@ from pySDC.core.ConvergenceController import ConvergenceController +from pySDC.projects.compression.compressed_mesh import compressed_mesh import numpy as np import libpressio @@ -9,7 +10,10 @@ def setup(self, controller, params, description, **kwargs): # configure which compressor to use "compressor_id": "sz3", # configure the set of metrics to be gathered - "early_config": {"pressio:metric": "composite", "composite:plugins": ["time", "size", "error_stat"]}, + "early_config": { + "pressio:metric": "composite", + "composite:plugins": ["time", "size", "error_stat"], + }, # configure SZ "compressor_config": { "pressio:abs": 1e-10, @@ -17,13 +21,18 @@ def setup(self, controller, params, description, **kwargs): } defaults = { - 'control_order': 0, + "control_order": 0, **super().setup(controller, params, description, **kwargs), - 'compressor_args': {**default_compressor_args, **params.get('compressor_args', {})}, - 'min_buffer_length': 12, + "compressor_args": { + **default_compressor_args, + **params.get("compressor_args", {}), + }, + "min_buffer_length": 12, } - self.compressor = libpressio.PressioCompressor.from_config(defaults['compressor_args']) + self.compressor = libpressio.PressioCompressor.from_config( + defaults["compressor_args"] + ) return defaults @@ -49,3 +58,47 @@ def post_iteration_processing(self, controller, S, **kwargs): # metrics = self.compressor.get_metrics() # print(metrics) + + +class Compression_Conv_Controller(ConvergenceController): + def setup(self, controller, params, description, **kwargs): + defaults = { + "control_order": 0, + "errBound": 1, + **super().setup(controller, params, description, **kwargs), + } + + # The bottom line gets access to manager but makes a new mesh + # x = compressed_mesh(init=((30,), None, np.float64)) + # self.manager = x.manager + self.manager = compressed_mesh(init=((30,), None, np.float64)).manager + self.manager.errBound = defaults["errBound"] + return defaults + + def dependencies(self, controller, description, **kwargs): + """ + Load estimator of embedded error. + + Args: + controller (pySDC.Controller): The controller + description (dict): The description object used to instantiate the controller + + Returns: + None + """ + + from pySDC.implementations.convergence_controller_classes.estimate_contraction_factor import ( + EstimateContractionFactor, + ) + + controller.add_convergence_controller( + EstimateContractionFactor, + description=description, + ) + + def post_iteration_processing(self, controller, S, **kwargs): + self.log(S.levels[0].status.contraction_factor, S, level=10) + self.log(S.levels[0].status.error_embedded_estimate, S) + + # def post_step_processing(self, controller, S, **kwargs): + # print(self.manager) diff --git a/pySDC/projects/compression/heat_example.py b/pySDC/projects/compression/heat_example.py new file mode 100644 index 0000000000..9e1ffa06db --- /dev/null +++ b/pySDC/projects/compression/heat_example.py @@ -0,0 +1,110 @@ +from pySDC.implementations.problem_classes.HeatEquation_ND_FD import heatNd_forced +from pySDC.implementations.sweeper_classes.imex_1st_order import imex_1st_order +from pySDC.implementations.controller_classes.controller_MPI import controller_MPI +from pySDC.implementations.controller_classes.controller_nonMPI import controller_nonMPI +from pySDC.helpers.stats_helper import get_sorted +from mpi4py import MPI +from pySDC.implementations.hooks.log_errors import LogGlobalErrorPostRun +from pySDC.implementations.hooks.log_solution import LogSolution +from pySDC.projects.compression.compressed_problems import heat_ND_compressed +from pySDC.projects.compression.log_datatype_creations import LogDatatypeCreations +from pySDC.projects.compression.compression_convergence_controller import ( + Compression_Conv_Controller, +) + + +def run_heat(residual_tolerance=1e-4, errBound=1e-8, resolution=64, Tend=1): + # setup communicator + # comm = MPI.COMM_WORLD if comm is None else comm + + # initialize problem parameters + problem_params = {} + problem_params["nu"] = 1.0 + problem_params["freq"] = (4, 4, 4) + problem_params["order"] = 4 + problem_params["lintol"] = 1e-7 + problem_params["liniter"] = 99 + problem_params["solver_type"] = "CG" + problem_params["nvars"] = ( + resolution, + resolution, + resolution, + ) # Have to be the same, Nx = Ny = Nz + problem_params["bc"] = "periodic" + + convergence_controllers = {} + convergence_controllers[Compression_Conv_Controller] = {"errBound": errBound} + + # initialize level parameters + level_params = {} + level_params["restol"] = residual_tolerance + level_params["dt"] = 1e-01 + level_params["nsweeps"] = 1 + + # initialize sweeper parameters + sweeper_params = {} + sweeper_params["node_type"] = "LEGENDRE" + sweeper_params["quad_type"] = "RADAU-RIGHT" + sweeper_params["QI"] = ["IE"] + sweeper_params["QE"] = ["PIC"] + sweeper_params["num_nodes"] = 3 + sweeper_params["initial_guess"] = "spread" + + # initialize step parameters + step_params = {} + step_params["maxiter"] = 50 # 50 + + # initialize controller parameters + controller_params = {} + controller_params["logger_level"] = 15 + controller_params["hook_class"] = [ + LogSolution, + LogGlobalErrorPostRun, + # LogDatatypeCreations, + ] + + # fill description dictionary for easy step instantiation + description = {} + # description['problem_class'] = heatNd_forced# heat_ND_compressed + description["problem_class"] = heat_ND_compressed + description["problem_params"] = problem_params + description["sweeper_class"] = imex_1st_order + description["sweeper_params"] = sweeper_params + description["level_params"] = level_params + description["step_params"] = step_params + description["convergence_controllers"] = convergence_controllers + + # instantiate controller + controller = controller_nonMPI( + controller_params=controller_params, description=description, num_procs=1 + ) + + # get initial values on finest level + P = controller.MS[0].levels[0].prob + uinit = P.u_exact(0.0) + + # call main function to get things done... + uend, stats = controller.run(u0=uinit, t0=0.0, Tend=Tend) + + return stats + + +def main(): + from pySDC.helpers.stats_helper import get_list_of_types, sort_stats, filter_stats + + stats = run_heat(Tend=0.3) + error = max([me[1] for me in get_sorted(stats, type="e_global_post_run")]) + # print(get_list_of_types(stats)) + # print("filter_stats", filter_stats(stats, type="u")) + # print("sort_stats", sort_stats(filter_stats(stats, type="u"), sortby="time")) + # u = get_sorted(stats, type="num_datatype_creations") + # print(u) + print(error) + # import matplotlib.pyplot as plt + + # plt.plot([me[0] for me in u], [me[1] for me in u]) + # plt.show() + + +if __name__ == "__main__": + main() diff --git a/pySDC/projects/compression/log_datatype_creations.py b/pySDC/projects/compression/log_datatype_creations.py new file mode 100644 index 0000000000..89b9272d69 --- /dev/null +++ b/pySDC/projects/compression/log_datatype_creations.py @@ -0,0 +1,32 @@ +from pySDC.core.Hooks import hooks + + +class LogDatatypeCreations(hooks): + """ + Store the solution at the end of each step as "u". + """ + + def post_step(self, step, level_number): + """ + Record solution at the end of the step + + Args: + step (pySDC.Step.step): the current step + level_number (int): the current level number + + Returns: + None + """ + super().post_step(step, level_number) + + L = step.levels[level_number] + + self.add_to_stats( + process=step.status.slot, + time=L.time + L.dt, + level=L.level_index, + iter=step.status.iter, + sweep=L.status.sweep, + type="num_datatype_creations", + value=L.u[0].manager.name, + ) diff --git a/pySDC/projects/compression/order.py b/pySDC/projects/compression/order.py index 1f10d8a37b..d93207a05a 100644 --- a/pySDC/projects/compression/order.py +++ b/pySDC/projects/compression/order.py @@ -9,27 +9,33 @@ from pySDC.projects.compression.compression_convergence_controller import Compression -MACHINEPRECISION = ( - 1e-8 # generous tolerance below which we ascribe errors to floating point rounding errors rather than compression -) +MACHINEPRECISION = 1e-8 # generous tolerance below which we ascribe errors to floating point rounding errors rather than compression LOGGER_LEVEL = 30 -def single_run(problem, description=None, thresh=1e-10, Tend=2e-1, useMPI=False, num_procs=1): +def single_run( + problem, description=None, thresh=1e-10, Tend=2e-1, useMPI=False, num_procs=1 +): description = {} if description is None else description compressor_args = {} - compressor_args['compressor_config'] = {'pressio:abs': thresh} + compressor_args["compressor_config"] = {"pressio:abs": thresh} if thresh > 0: - description['convergence_controllers'] = {Compression: {'compressor_args': compressor_args}} + description["convergence_controllers"] = { + Compression: {"compressor_args": compressor_args} + } controller_params = { - 'mssdc_jac': False, - 'logger_level': LOGGER_LEVEL, + "mssdc_jac": False, + "logger_level": LOGGER_LEVEL, } - error_hook = error_hooks.LogGlobalErrorPostRunMPI if useMPI else error_hooks.LogGlobalErrorPostRun + error_hook = ( + error_hooks.LogGlobalErrorPostRunMPI + if useMPI + else error_hooks.LogGlobalErrorPostRun + ) stats, _, _ = problem( custom_description=description, @@ -46,92 +52,131 @@ def single_run(problem, description=None, thresh=1e-10, Tend=2e-1, useMPI=False, comm = MPI.COMM_WORLD else: comm = None - e = min([me[1] for me in get_sorted(stats, type='e_global_post_run', comm=comm)]) + e = min([me[1] for me in get_sorted(stats, type="e_global_post_run", comm=comm)]) return e -def multiple_runs(problem, values, expected_order, mode='dt', thresh=1e-10, useMPI=False, num_procs=1, **kwargs): +def multiple_runs( + problem, + values, + expected_order, + mode="dt", + thresh=1e-10, + useMPI=False, + num_procs=1, + **kwargs, +): errors = np.zeros_like(values) description = { - 'level_params': {}, - 'problam_params': {}, - 'step_params': {}, + "level_params": {}, + "problam_params": {}, + "step_params": {}, } - if mode == 'dt': - description['step_params'] = {'maxiter': expected_order} - elif mode == 'nvars': - description['problem_params'] = {'order': expected_order} + if mode == "dt": + description["step_params"] = {"maxiter": expected_order} + elif mode == "nvars": + description["problem_params"] = {"order": expected_order} for i in range(len(values)): - if mode == 'dt': - description['level_params']['dt'] = values[i] + if mode == "dt": + description["level_params"]["dt"] = values[i] Tend = values[i] * (5 if num_procs == 1 else 2 * num_procs) - elif mode == 'nvars': - description['problem_params']['nvars'] = values[i] + elif mode == "nvars": + description["problem_params"]["nvars"] = values[i] Tend = 2e-1 - errors[i] = single_run(problem, description, thresh=thresh, Tend=Tend, useMPI=useMPI, num_procs=num_procs) + errors[i] = single_run( + problem, + description, + thresh=thresh, + Tend=Tend, + useMPI=useMPI, + num_procs=num_procs, + ) return values, errors def get_order(values, errors, thresh=1e-16, expected_order=None): values = np.array(values) idx = np.argsort(values) - local_orders = np.log(errors[idx][1:] / errors[idx][:-1]) / np.log(values[idx][1:] / values[idx][:-1]) + local_orders = np.log(errors[idx][1:] / errors[idx][:-1]) / np.log( + values[idx][1:] / values[idx][:-1] + ) order = np.mean(local_orders[errors[idx][1:] > max([thresh, MACHINEPRECISION])]) if expected_order is not None: - assert np.isclose(order, expected_order, atol=0.5), f"Expected order {expected_order}, but got {order:.2f}!" + assert np.isclose( + order, expected_order, atol=0.5 + ), f"Expected order {expected_order}, but got {order:.2f}!" return order -def plot_order(values, errors, ax, thresh=1e-16, color='black', expected_order=None, **kwargs): +def plot_order( + values, errors, ax, thresh=1e-16, color="black", expected_order=None, **kwargs +): values = np.array(values) order = get_order(values, errors, thresh=thresh, expected_order=expected_order) ax.scatter(values, errors, color=color, **kwargs) - ax.loglog(values, errors[0] * (values / values[0]) ** order, color=color, label=f'p={order:.2f}', **kwargs) + ax.loglog( + values, + errors[0] * (values / values[0]) ** order, + color=color, + label=f"p={order:.2f}", + **kwargs, + ) def plot_order_in_time(ax, thresh, useMPI=False, num_procs=1): problem = run_advection base_configs_dt = { - 'values': np.array([2.0 ** (-i) for i in [2, 3, 4, 5, 6, 7, 8, 9]]), - 'mode': 'dt', - 'ax': ax, - 'thresh': thresh, + "values": np.array([2.0 ** (-i) for i in [2, 3, 4, 5, 6, 7, 8, 9]]), + "mode": "dt", + "ax": ax, + "thresh": thresh, } configs_dt = {} - configs_dt[2] = {**base_configs_dt, 'color': 'black'} - configs_dt[3] = {**base_configs_dt, 'color': 'magenta'} - configs_dt[4] = {**base_configs_dt, 'color': 'teal'} - configs_dt[5] = {**base_configs_dt, 'color': 'orange'} + configs_dt[2] = {**base_configs_dt, "color": "black"} + configs_dt[3] = {**base_configs_dt, "color": "magenta"} + configs_dt[4] = {**base_configs_dt, "color": "teal"} + configs_dt[5] = {**base_configs_dt, "color": "orange"} # configs_dt[6] = {**base_configs_dt, 'color': 'blue'} for key in configs_dt.keys(): values, errors = multiple_runs( - problem, expected_order=key, useMPI=useMPI, **configs_dt[key], num_procs=num_procs + problem, + expected_order=key, + useMPI=useMPI, + **configs_dt[key], + num_procs=num_procs, ) plot_order( values, errors, - ax=configs_dt[key]['ax'], - thresh=configs_dt[key]['thresh'] * 1e2, - color=configs_dt[key]['color'], + ax=configs_dt[key]["ax"], + thresh=configs_dt[key]["thresh"] * 1e2, + color=configs_dt[key]["color"], expected_order=key + 1, ) - base_configs_dt['ax'].set_xlabel(r'$\Delta t$') - base_configs_dt['ax'].set_ylabel('local error') - base_configs_dt['ax'].axhline( - base_configs_dt['thresh'], color='grey', ls='--', label=rf'$\|\delta\|={{{thresh:.0e}}}$' + base_configs_dt["ax"].set_xlabel(r"$\Delta t$") + base_configs_dt["ax"].set_ylabel("local error") + base_configs_dt["ax"].axhline( + base_configs_dt["thresh"], + color="grey", + ls="--", + label=rf"$\|\delta\|={{{thresh:.0e}}}$", ) - base_configs_dt['ax'].legend(frameon=False) + base_configs_dt["ax"].legend(frameon=False) def order_in_time_different_error_bounds(): fig, axs = plt.subplots( - 2, 2, figsize=figsize_by_journal('Springer_Numerical_Algorithms', 1.0, 1.0), sharex=True, sharey=True + 2, + 2, + figsize=figsize_by_journal("Springer_Numerical_Algorithms", 1.0, 1.0), + sharex=True, + sharey=True, ) threshs = [1e-6, 1e-8, 1e-10, 1e-12] @@ -139,14 +184,14 @@ def order_in_time_different_error_bounds(): ax = axs.flatten()[i] plot_order_in_time(ax, threshs[i]) if i != 2: - ax.set_ylabel('') - ax.set_xlabel('') - fig.suptitle('Order in time for advection problem') + ax.set_ylabel("") + ax.set_xlabel("") + fig.suptitle("Order in time for advection problem") fig.tight_layout() - fig.savefig('compression-order-time.pdf') + fig.savefig("compression-order-time.pdf") -if __name__ == '__main__': +if __name__ == "__main__": order_in_time_different_error_bounds() # base_configs_nvars = { diff --git a/pySDC/tests/test_projects/test_compression/test_manager.py b/pySDC/tests/test_projects/test_compression/test_manager.py new file mode 100644 index 0000000000..58a5c5322f --- /dev/null +++ b/pySDC/tests/test_projects/test_compression/test_manager.py @@ -0,0 +1,71 @@ +import pytest + + +# Test to compress an array of numbers and decompress it +@pytest.mark.libpressio +@pytest.mark.parametrize("shape_t", [(100,), (100, 100), (100, 100, 100)]) +@pytest.mark.parametrize("errorBound", [1e-1, 1e-3]) +def test_compression(shape_t, errorBound): + from pySDC.projects.compression.compressed_mesh import compressed_mesh + from pySDC.implementations.datatype_classes.mesh import mesh + import numpy as np + from pySDC.projects.compression.CRAM_Manager import CRAM_Manager + + np_rng = np.random.default_rng(seed=4) + arr = np_rng.random(shape_t) + + dtype = compressed_mesh(init=(shape_t, None, np.float64)) + dtype2 = mesh(init=(shape_t, None, np.dtype("float64"))) + dtype2[:] = arr[:] + dtype.manager.compress(arr[:], dtype.name, 0, errBound=errorBound) + + error = abs(dtype[:] - dtype2[:]) + assert ( + error > 0 or errorBound < 1e-1 + ), f"Compression did nothing(lossless compression), got error:{error:.2e} with error bound: {errorBound:.2e}" + assert ( + error <= errorBound + ), f"Error too large, compression failed, got error: {error:.2e} with error bound: {errorBound:.2e}" + + +def test_mesh_operations(): + from pySDC.projects.compression.compressed_mesh import compressed_mesh + import numpy as np + + # TODO: Add method to change default error bound before creating first mesh + arr1 = compressed_mesh(init=((30,), None, np.float64), val=1) + arr2 = compressed_mesh(init=((30,), None, np.float64), val=2.0) + + np_arr1 = np.ones((30,)) * 3.0 + + assert all( + me == 3.0 for me in (arr1 + arr2) + ), "Addition of two compressed meshes failed unexpectedly." + assert all( + me == -1 for me in (arr1 - arr2) + ), "Subtraction of two compressed meshes failed unexpectedly." + assert all( + me == 4 for me in (arr1 + np_arr1) + ), "Addition of a compressed mesh and numpy array failed unexpectedly." + assert all( + me == -2 for me in (arr1 - np_arr1) + ), "Subtraction of a compressed mesh and numpy array failed unexpectedly." + assert all( + me == 5 for me in (4.0 + arr1) + ), "Addition of a float and compressed mesh failed unexpectedly." + assert all( + me == 2 for me in (4.0 - arr2) + ), "Subtraction of a float and compressed mesh failed unexpectedly." + assert all( + me == 4 for me in (4.0 * arr1) + ), "Multiplication of a float and compressed mesh failed unexpectedly." + assert all( + me == 5 for me in (arr1 + 4.0) + ), "Addition of a compressed mesh and float failed unexpectedly." + assert all( + me == -2 for me in (arr2 - 4.0) + ), "Subtraction of a compressed mesh and float failed unexpectedly." + + +if __name__ == "__main__": + test_mesh_operations() diff --git a/pySDC/tests/test_projects/test_compression/test_proof_of_concept.py b/pySDC/tests/test_projects/test_compression/test_proof_of_concept.py index 29296d17a2..258a0c2c56 100644 --- a/pySDC/tests/test_projects/test_compression/test_proof_of_concept.py +++ b/pySDC/tests/test_projects/test_compression/test_proof_of_concept.py @@ -18,7 +18,9 @@ def test_compression_proof_of_concept(thresh, useMPI, num_procs): p = subprocess.Popen(cmd, env=my_env, cwd=".") p.wait() - assert p.returncode == 0, 'ERROR: did not get return code 0, got %s with %2i processes' % ( + assert ( + p.returncode == 0 + ), "ERROR: did not get return code 0, got %s with %2i processes" % ( p.returncode, num_procs, ) @@ -27,19 +29,22 @@ def test_compression_proof_of_concept(thresh, useMPI, num_procs): def run_single_test(thresh, useMPI, num_procs): - print(f'Running with error bound {thresh} and {num_procs}. MPI: {useMPI}') + print(f"Running with error bound {thresh} and {num_procs}. MPI: {useMPI}") import matplotlib.pyplot as plt import os from pySDC.projects.compression.order import plot_order_in_time fig, ax = plt.subplots(figsize=(3, 2)) plot_order_in_time(ax=ax, thresh=thresh, useMPI=useMPI, num_procs=num_procs) - if os.path.exists('data'): + if os.path.exists("data"): ax.set_title(f'{num_procs} procs, {"MPI" if useMPI else "non MPI"}') - fig.savefig(f'data/compression_order_time_advection_d={thresh:.2e}_n={num_procs}_MPI={useMPI}.png', dpi=200) + fig.savefig( + f"data/compression_order_time_advection_d={thresh:.2e}_n={num_procs}_MPI={useMPI}.png", + dpi=200, + ) -if __name__ == '__main__': +if __name__ == "__main__": import sys # defaults for arguments @@ -49,15 +54,17 @@ def run_single_test(thresh, useMPI, num_procs): # parse command line arguments for i in range(len(sys.argv)): - if sys.argv[i] == '-n': + if sys.argv[i] == "-n": num_procs = int(sys.argv[i + 1]) - elif sys.argv[i] == '-M': - useMPI = True if sys.argv[i + 1] == 'True' else False - elif sys.argv[i] == '-t': + elif sys.argv[i] == "-M": + useMPI = True if sys.argv[i + 1] == "True" else False + elif sys.argv[i] == "-t": thresh = float(sys.argv[i + 1]) # execute test - if '--use-subprocess' in sys.argv: - test_compression_proof_of_concept(thresh=thresh, useMPI=useMPI, num_procs=num_procs) + if "--use-subprocess" in sys.argv: + test_compression_proof_of_concept( + thresh=thresh, useMPI=useMPI, num_procs=num_procs + ) else: run_single_test(thresh=thresh, useMPI=useMPI, num_procs=num_procs) From bc93c309229d3d72209dd462447e661fa3d678eb Mon Sep 17 00:00:00 2001 From: Sansriti Ranjan Date: Wed, 22 Nov 2023 10:03:37 -0500 Subject: [PATCH 2/5] New push to branch merge --- .gitignore | 4 + pySDC/implementations/hooks/log_errors.py | 9 +- .../problem_classes/AllenCahn_MPIFFT.py | 40 +- .../compression/compressed_mesh.py | 347 +++++ .../compression/datatype_playground.py | 357 +++++ .../compression/heat_compressed.py | 11 + pySDC/playgrounds/compression/heat_example.py | 82 ++ .../projects/compression/AllenCahn_MPIFFT.py | 282 ++++ pySDC/projects/compression/CRAM_Manager.py | 371 +++++- pySDC/projects/compression/Untitled.ipynb | 895 +++++++++++++ .../projects/compression/allencahn_example.py | 183 ++- pySDC/projects/compression/cache_manager.py | 102 ++ pySDC/projects/compression/compressed_mesh.py | 24 +- .../compression_convergence_controller.py | 13 +- pySDC/projects/compression/heat_example.py | 137 +- .../projects/compression/log_cache_history.py | 32 + .../compression/log_cache_invalidates.py | 52 + pySDC/projects/compression/log_clear_stats.py | 41 + .../compression/log_compression_ratio.py | 63 + .../compression/log_num_comp_decomp_calls.py | 94 ++ .../compression/log_num_registered_var.py | 63 + .../projects/compression/log_time_metrics.py | 163 +++ .../compression/model_cache_compcalls.ipynb | 1174 +++++++++++++++++ pySDC/projects/compression/order.py | 30 +- .../compression/run_serial_examples.py | 290 ++++ .../compression/sweeper_imex_compression.py | 185 +++ pySDC/projects/compression/test.py | 18 + .../test_compression/test_cache_manager.py | 1 + .../test_compression/test_manager.py | 32 +- .../test_compression/test_proof_of_concept.py | 8 +- 30 files changed, 4920 insertions(+), 183 deletions(-) create mode 100644 pySDC/playgrounds/compression/compressed_mesh.py create mode 100644 pySDC/playgrounds/compression/datatype_playground.py create mode 100644 pySDC/playgrounds/compression/heat_compressed.py create mode 100644 pySDC/playgrounds/compression/heat_example.py create mode 100644 pySDC/projects/compression/AllenCahn_MPIFFT.py create mode 100644 pySDC/projects/compression/Untitled.ipynb create mode 100644 pySDC/projects/compression/cache_manager.py create mode 100644 pySDC/projects/compression/log_cache_history.py create mode 100644 pySDC/projects/compression/log_cache_invalidates.py create mode 100644 pySDC/projects/compression/log_clear_stats.py create mode 100644 pySDC/projects/compression/log_compression_ratio.py create mode 100644 pySDC/projects/compression/log_num_comp_decomp_calls.py create mode 100644 pySDC/projects/compression/log_num_registered_var.py create mode 100644 pySDC/projects/compression/log_time_metrics.py create mode 100644 pySDC/projects/compression/model_cache_compcalls.ipynb create mode 100644 pySDC/projects/compression/run_serial_examples.py create mode 100644 pySDC/projects/compression/sweeper_imex_compression.py create mode 100644 pySDC/projects/compression/test.py create mode 100644 pySDC/tests/test_projects/test_compression/test_cache_manager.py diff --git a/.gitignore b/.gitignore index 7ab0ead3bb..75b17bd9ed 100644 --- a/.gitignore +++ b/.gitignore @@ -6,6 +6,10 @@ *detail.txt data/* step_*.png +/pySDC/projects/compression/*.png +/pySDC/projects/compression/*.txt +/pySDC/projects/compression/*.csv +.flakeheaven_cache/ *.pkl *.swp diff --git a/pySDC/implementations/hooks/log_errors.py b/pySDC/implementations/hooks/log_errors.py index d5833c3e7c..8ee2f77684 100644 --- a/pySDC/implementations/hooks/log_errors.py +++ b/pySDC/implementations/hooks/log_errors.py @@ -72,10 +72,7 @@ def log_local_error(self, step, level_number, suffix=""): iter=step.status.iter, sweep=L.status.sweep, type=f"e_local{suffix}", - value=abs( - L.prob.u_exact(t=L.time + L.dt, u_init=L.u[0] * 1.0, t_init=L.time) - - L.uend - ), + value=abs(L.prob.u_exact(t=L.time + L.dt, u_init=L.u[0] * 1.0, t_init=L.time) - L.uend), ) @@ -145,9 +142,7 @@ def post_run(self, step, level_number): u_num = self.get_final_solution(L) u_ref = L.prob.u_exact(t=self.t_last_solution) - self.logger.info( - f"Finished with a global error of e={abs(u_num-u_ref):.2e}" - ) + self.logger.info(f"Finished with a global error of e={abs(u_num-u_ref):.2e}") self.add_to_stats( process=step.status.slot, diff --git a/pySDC/implementations/problem_classes/AllenCahn_MPIFFT.py b/pySDC/implementations/problem_classes/AllenCahn_MPIFFT.py index 948e6db285..702c128bf8 100644 --- a/pySDC/implementations/problem_classes/AllenCahn_MPIFFT.py +++ b/pySDC/implementations/problem_classes/AllenCahn_MPIFFT.py @@ -26,9 +26,7 @@ class allencahn_imex(ptype): dtype_u = mesh dtype_f = imex_mesh - def __init__( - self, nvars, eps, radius, spectral, dw=0.0, L=1.0, init_type="circle", comm=None - ): + def __init__(self, nvars, eps, radius, spectral, dw=0.0, L=1.0, init_type="circle", comm=None): """ Initialization routine @@ -109,9 +107,7 @@ def eval_f(self, u, t): if self.eps > 0: tmp = self.fft.backward(u) - tmpf = -2.0 / self.eps**2 * tmp * (1.0 - tmp) * ( - 1.0 - 2.0 * tmp - ) - 6.0 * self.dw * tmp * (1.0 - tmp) + tmpf = -2.0 / self.eps**2 * tmp * (1.0 - tmp) * (1.0 - 2.0 * tmp) - 6.0 * self.dw * tmp * (1.0 - tmp) f.expl[:] = self.fft.forward(tmpf) else: @@ -120,9 +116,7 @@ def eval_f(self, u, t): f.impl[:] = self.fft.backward(lap_u_hat, f.impl) if self.eps > 0: - f.expl = -2.0 / self.eps**2 * u * (1.0 - u) * ( - 1.0 - 2.0 * u - ) - 6.0 * self.dw * u * (1.0 - u) + f.expl = -2.0 / self.eps**2 * u * (1.0 - u) * (1.0 - 2.0 * u) - 6.0 * self.dw * u * (1.0 - u) return f @@ -167,14 +161,10 @@ def u_exact(self, t): if self.init_type == "circle": r2 = (self.X[0] - 0.5) ** 2 + (self.X[1] - 0.5) ** 2 if self.spectral: - tmp = 0.5 * ( - 1.0 + np.tanh((self.radius - np.sqrt(r2)) / (np.sqrt(2) * self.eps)) - ) + tmp = 0.5 * (1.0 + np.tanh((self.radius - np.sqrt(r2)) / (np.sqrt(2) * self.eps))) me[:] = self.fft.forward(tmp) else: - me[:] = 0.5 * ( - 1.0 + np.tanh((self.radius - np.sqrt(r2)) / (np.sqrt(2) * self.eps)) - ) + me[:] = 0.5 * (1.0 + np.tanh((self.radius - np.sqrt(r2)) / (np.sqrt(2) * self.eps))) elif self.init_type == "circle_rand": ndim = len(me[:].shape) L = int(self.L) @@ -182,26 +172,16 @@ def u_exact(self, t): np.random.seed(1) lbound = 3.0 * self.eps ubound = 0.5 - self.eps - rand_radii = (ubound - lbound) * np.random.random_sample( - size=tuple([L] * ndim) - ) + lbound + rand_radii = (ubound - lbound) * np.random.random_sample(size=tuple([L] * ndim)) + lbound # distribute circles/spheres tmp = newDistArray(self.fft, False) if ndim == 2: for i in range(0, L): for j in range(0, L): # build radius - r2 = (self.X[0] + i - L + 0.5) ** 2 + ( - self.X[1] + j - L + 0.5 - ) ** 2 + r2 = (self.X[0] + i - L + 0.5) ** 2 + (self.X[1] + j - L + 0.5) ** 2 # add this blob, shifted by 1 to avoid issues with adding up negative contributions - tmp += ( - np.tanh( - (rand_radii[i, j] - np.sqrt(r2)) - / (np.sqrt(2) * self.eps) - ) - + 1 - ) + tmp += np.tanh((rand_radii[i, j] - np.sqrt(r2)) / (np.sqrt(2) * self.eps)) + 1 # normalize to [0,1] tmp *= 0.5 assert np.all(tmp <= 1.0) @@ -210,9 +190,7 @@ def u_exact(self, t): else: me[:] = tmp[:] else: - raise NotImplementedError( - "type of initial value not implemented, got %s" % self.init_type - ) + raise NotImplementedError("type of initial value not implemented, got %s" % self.init_type) return me diff --git a/pySDC/playgrounds/compression/compressed_mesh.py b/pySDC/playgrounds/compression/compressed_mesh.py new file mode 100644 index 0000000000..d1334f9072 --- /dev/null +++ b/pySDC/playgrounds/compression/compressed_mesh.py @@ -0,0 +1,347 @@ +# from pySDC.implementations.datatype_classes.compressed_mesh import compressed_mesh +import numpy as np +from pySDC.projects.compression.CRAM_Manager import CRAM_Manager +from pySDC.core.Errors import DataError + + +class compressed_mesh(object): + """ + Mesh data type with arbitrary dimensions + + This data type can be used whenever structured data with a single unknown per point in space is required + + Attributes: + values (np.ndarray): contains the ndarray of the values + """ + + manager = CRAM_Manager("ABS", "sz", 1) + + def __init__(self, init=None, val=0.0): + """ + Initialization routine + + Args: + init: can either be a tuple (one int per dimension) or a number (if only one dimension is requested) + or another mesh object + val: initial value (default: None) + Raises: + DataError: if init is none of the types above + """ + self.name = str(self.manager.name + 1) + self.manager.name += 1 + + # if init is another mesh, do a copy (init by copy) + if isinstance(init, compressed_mesh): + values = self.manager.decompress(init.name, 0) # TODO: Modify manager to copy compressed buffer + self.manager.registerVar( + self.name, + values.shape, + values.dtype, + numVectors=1, + errBoundMode="ABS", + compType="sz3", + errBound=1e-5, + ) + self.manager.compress(values.copy(), self.name, 0) + # if init is a number or a tuple of numbers, create mesh object with val as initial value + elif isinstance(init, tuple) or isinstance(init, int): + self.manager.registerVar( + self.name, + init[0], + init[2], + numVectors=1, + errBoundMode="ABS", + compType="sz3", + errBound=1e-5, + ) + self.manager.compress(np.full(init[0], fill_value=val), self.name, 0) + # something is wrong, if none of the ones above hit + else: + raise DataError("something went wrong during %s initialization" % type(self)) + + def __del__(self): + # print('Delete'+' ' +self.name) + self.manager.remove(self.name, 0) + + def __add__(self, other): + """ + Overloading the addition operator for mesh types + + Args: + other (mesh.mesh): mesh object to be added + Raises: + DataError: if other is not a mesh object + Returns: + mesh.mesh: sum of caller and other values (self+other) + """ + + if isinstance(other, compressed_mesh): + # always create new mesh, since otherwise c = a + b changes a as well! + me = compressed_mesh(self) + values = self.manager.decompress(self.name, 0) + ov = self.manager.decompress(other.name, 0) + self.manager.compress(values + ov, me.name, 0) + return me + else: + raise DataError("Type error: cannot add %s to %s" % (type(other), type(self))) + + def __sub__(self, other): + """ + Overloading the subtraction operator for mesh types + + Args: + other (mesh.mesh): mesh object to be subtracted + Raises: + DataError: if other is not a mesh object + Returns: + mesh.mesh: differences between caller and other values (self-other) + """ + + if isinstance(other, compressed_mesh): + # always create new mesh, since otherwise c = a - b changes a as well! + me = compressed_mesh(self) + values = self.manager.decompress(self.name, 0) + ov = self.manager.decompress(other.name, 0) + self.manager.compress(values - ov, me.name, 0) + return me + else: + raise DataError("Type error: cannot subtract %s from %s" % (type(other), type(self))) + + def __rmul__(self, other): + """ + Overloading the right multiply by factor operator for mesh types + + Args: + other (float): factor + Raises: + DataError: is other is not a float + Returns: + mesh.mesh: copy of original values scaled by factor + """ + + if isinstance(other, float) or isinstance(other, complex): + # always create new mesh, since otherwise c = f*a changes a as well! + values = self.manager.decompress(self.name, 0) + me = compressed_mesh(self) + self.manager.compress(values * other, me.name, 0) + return me + else: + raise DataError("Type error: cannot multiply %s to %s" % (type(other), type(self))) + + def __abs__(self): + """ + Overloading the abs operator for mesh types + + Returns: + float: absolute maximum of all mesh values + """ + + # take absolute values of the mesh values + values = self.manager.decompress(self.name, 0) + absval = abs(values) + + # return maximum + return np.amax(absval) + + def __setitem__(self, key, newvalue): + # print("SET: ", key, newvalue) + if type(newvalue) == type(self): # Assigning compressed mesh + arr_temp = self.manager.decompress(newvalue.name, 0) + self.manager.compress(arr_temp, self.name, 0) + else: + array = self.manager.decompress(self.name, 0) + array.__setitem__(key, newvalue) + self.manager.compress(array, self.name, 0) + + def __getitem__(self, key): + array = self.manager.decompress(self.name, 0) + return array.__getitem__(key) + + def __str__(self): + return str(self[:]) + + def flatten(self): + return self.manager.decompress(self.name, 0).flatten() + + +''' + def apply_mat(self, A): + """ + Matrix multiplication operator + + Args: + A: a matrix + + Returns: + mesh.mesh: component multiplied by the matrix A + """ + if not A.shape[1] == self.values.shape[0]: + raise DataError("ERROR: cannot apply operator %s to %s" % (A.shape[1], self)) + + me = mesh(A.shape[0]) + me.values = A.dot(self.values) + + return me + + def isend(self, dest=None, tag=None, comm=None): + """ + Routine for sending data forward in time (non-blocking) + + Args: + dest (int): target rank + tag (int): communication tag + comm: communicator + + Returns: + request handle + """ + return comm.Issend(self.values[:], dest=dest, tag=tag) + + def irecv(self, source=None, tag=None, comm=None): + """ + Routine for receiving in time + + Args: + source (int): source rank + tag (int): communication tag + comm: communicator + + Returns: + None + """ + return comm.Irecv(self.values[:], source=source, tag=tag) + + def bcast(self, root=None, comm=None): + """ + Routine for broadcasting values + + Args: + root (int): process with value to broadcast + comm: communicator + + Returns: + broadcasted values + """ + return comm.bcast(self, root=root) +''' + + +class imex_mesh_compressed(object): + """ + RHS data type for meshes with implicit and explicit components + + This data type can be used to have RHS with 2 components (here implicit and explicit) + + Attributes: + impl (mesh.mesh): implicit part + expl (mesh.mesh): explicit part + """ + + def __init__(self, init, val=0.0): + """ + Initialization routine + + Args: + init: can either be a tuple (one int per dimension) or a number (if only one dimension is requested) + or another rhs_imex_mesh object + val (float): an initial number (default: 0.0) + Raises: + DataError: if init is none of the types above + """ + + # if init is another rhs_imex_mesh, do a copy (init by copy) + if isinstance(init, type(self)): + self.impl = compressed_mesh(init.impl) + self.expl = compressed_mesh(init.expl) + # if init is a number or a tuple of numbers, create compressed_mesh object with None as initial value + elif isinstance(init, tuple) or isinstance(init, int): + self.impl = compressed_mesh(init, val=val) + self.expl = compressed_mesh(init, val=val) + # something is wrong, if none of the ones above hit + else: + raise DataError("something went wrong during %s initialization" % type(self)) + + # def __sub__(self, other): + # """ + # Overloading the subtraction operator for rhs types + + # Args: + # other (compressed_mesh.rhs_imex_compressed_mesh): rhs object to be subtracted + # Raises: + # DataError: if other is not a rhs object + # Returns: + # compressed_mesh.rhs_imex_compressed_mesh: differences between caller and other values (self-other) + # """ + + # if isinstance(other, rhs_imex_compressed_mesh): + # # always create new rhs_imex_compressed_mesh, since otherwise c = a - b changes a as well! + # me = rhs_imex_compressed_mesh(self) + # me.impl.values = self.impl.values - other.impl.values + # me.expl.values = self.expl.values - other.expl.values + # return me + # else: + # raise DataError("Type error: cannot subtract %s from %s" % (type(other), type(self))) + + # def __add__(self, other): + # """ + # Overloading the addition operator for rhs types + + # Args: + # other (compressed_mesh.rhs_imex_compressed_mesh): rhs object to be added + # Raises: + # DataError: if other is not a rhs object + # Returns: + # compressed_mesh.rhs_imex_compressed_mesh: sum of caller and other values (self-other) + # """ + + # if isinstance(other, rhs_imex_compressed_mesh): + # # always create new rhs_imex_compressed_mesh, since otherwise c = a + b changes a as well! + # me = rhs_imex_compressed_mesh(self) + # me.impl.values = self.impl.values + other.impl.values + # me.expl.values = self.expl.values + other.expl.values + # return me + # else: + # raise DataError("Type error: cannot add %s to %s" % (type(other), type(self))) + + # def __rmul__(self, other): + # """ + # Overloading the right multiply by factor operator for compressed_mesh types + + # Args: + # other (float): factor + # Raises: + # DataError: is other is not a float + # Returns: + # compressed_mesh.rhs_imex_compressed_mesh: copy of original values scaled by factor + # """ + + # if isinstance(other, float): + # # always create new rhs_imex_compressed_mesh + # me = rhs_imex_compressed_mesh(self) + # me.impl.values = other * self.impl.values + # me.expl.values = other * self.expl.values + # return me + # else: + # raise DataError("Type error: cannot multiply %s to %s" % (type(other), type(self))) + + # def apply_mat(self, A): + # """ + # Matrix multiplication operator + + # Args: + # A: a matrix + + # Returns: + # compressed_mesh.rhs_imex_compressed_mesh: each component multiplied by the matrix A + # """ + + # if not A.shape[1] == self.impl.values.shape[0]: + # raise DataError("ERROR: cannot apply operator %s to %s" % (A, self.impl)) + # if not A.shape[1] == self.expl.values.shape[0]: + # raise DataError("ERROR: cannot apply operator %s to %s" % (A, self.expl)) + + # me = rhs_imex_compressed_mesh(A.shape[1]) + # me.impl.values = A.dot(self.impl.values) + # me.expl.values = A.dot(self.expl.values) + + # return me diff --git a/pySDC/playgrounds/compression/datatype_playground.py b/pySDC/playgrounds/compression/datatype_playground.py new file mode 100644 index 0000000000..84f6c971b6 --- /dev/null +++ b/pySDC/playgrounds/compression/datatype_playground.py @@ -0,0 +1,357 @@ +from pySDC.implementations.datatype_classes.mesh import mesh +import numpy as np +from pySDC.projects.compression.CRAM_Manager import CRAM_Manager +from pySDC.core.Errors import DataError + +# class compressed_mesh(np.ndarray): +# def __new__(cls, init, val=0.0, varName="---", **kwargs): +# if isinstance(init, compressed_mesh): +# obj = np.ndarray.__new__(cls, shape=init.shape, dtype=init.dtype, **kwargs) +# obj._comm = init._comm +# obj.varName = varName +# obj[:] = init[:] +# manager.registerVar( +# varName, +# init, +# init.dtype, +# numVectors=1, +# errBoundMode="ABS", +# compType="sz", +# errBound=1e-5, +# ) + +# elif ( +# isinstance(init, tuple) +# and (init[1] is None or isinstance(init[1], MPI.Intracomm)) +# and isinstance(init[2], np.dtype) +# ): +# obj = np.ndarray.__new__(cls, init[0], dtype=init[2], **kwargs) +# obj.fill(val) +# obj._comm = init[1] +# obj.varName = varName +# manager.registerVar( +# varName, +# init, +# init[2], +# numVectors=1, +# errBoundMode="ABS", +# compType="sz3", +# errBound=1e-5, +# ) + +# else: +# raise NotImplementedError(type(init)) +# return obj + +# # compressor manager, setter and getter +# # Operations: Assignment, add, subtract, scale + +# def __getitem__(self, key): +# array = manager.decompress(self.varName, 0) +# return array.__getitem__(key) +# # print("Get: ", key)# super().__getitem__(key)) +# # if isinstance(key, slice): +# # array = manager.decompress(self.varName,0) +# # return array.__getitem__(key) +# # indices = range(*key.indices(len(self.list))) +# # return [self.list[i] for i in indices] + +# # return super().__getitem__(key) +# # return manager.decompress(self.varName,0) + +# def __setitem__(self, key, newvalue): +# print("SET: ", key, newvalue) +# array = manager.decompress(self.varName, 0) +# array.__setitem__(key, newvalue) +# manager.compress(array, self.varName, 0) + +# # if isinstance(key, slice): +# # if newvalue == 1: +# # array = np.ones(self.init.shape)*newvalue +# # self.manager.compress(array, self.varName,0) +# # else: +# # array = self.manager.decompress(self.varName,0) +# # array.__setitem__(key, newvalue) +# # self.manager.compress(array, self.varName,0) +# # else: +# # array = self.manager.decompress(self.varName,0) +# # array.__setitem__(key, newvalue) +# # #super().__setitem__(key, newvalue) +# # #self.manager.compress(newvalue, self.varName,0) + +# def __array_finalize__(self, obj): +# """ +# Finalizing the datatype. Without this, new datatypes do not 'inherit' the communicator. +# """ +# if obj is None: +# return +# self._comm = getattr(obj, "_comm", None) +# self.varName = getattr(obj, "varName", None) + +# def __array_ufunc__(self, ufunc, method, *inputs, out=None, **kwargs): +# """ +# Overriding default ufunc, cf. https://numpy.org/doc/stable/user/basics.subclassing.html#array-ufunc-for-ufuncs +# """ +# args = [] +# comm = None +# varName = None +# print("Inputs: ", inputs) +# for _, input_ in enumerate(inputs): +# if isinstance(input_, compressed_mesh): +# array = manager.decompress(input_.varName, 0) +# args.append(array.view(np.ndarray)) +# comm = input_._comm +# varName = input_.varName +# else: +# args.append(input_) +# results = super(compressed_mesh, self).__array_ufunc__(ufunc, method, *args, **kwargs).view(np.ndarray) +# if not method == "reduce": +# cprss_array = compressed_mesh(input_, varName=str(name + 1)) +# cprss_array._comm = comm +# cprss_array[:] = results +# return cprss_array + +# # def __add__(self, x) +# # a = manager.decompress(self.varName,0) +# # b = manager.decompress(x.varName,0) + +# # c = a + b + + +class compressed_meshV2(object): + """ + Mesh data type with arbitrary dimensions + + This data type can be used whenever structured data with a single unknown per point in space is required + + Attributes: + values (np.ndarray): contains the ndarray of the values + """ + + manager = CRAM_Manager("ABS", "sz", 1) + + def __init__(self, init=None, val=0.0): + """ + Initialization routine + + Args: + init: can either be a tuple (one int per dimension) or a number (if only one dimension is requested) + or another mesh object + val: initial value (default: None) + Raises: + DataError: if init is none of the types above + """ + self.name = str(self.manager.name + 1) + self.manager.name += 1 + + # if init is another mesh, do a copy (init by copy) + if isinstance(init, compressed_meshV2): + values = self.manager.decompress(init.name, 0) # TODO: Modify manager to copy compressed buffer + self.manager.registerVar( + self.name, + values.shape, + values.dtype, + numVectors=1, + errBoundMode="ABS", + compType="sz3", + errBound=1e-5, + ) + self.manager.compress(values.copy(), self.name, 0) + # if init is a number or a tuple of numbers, create mesh object with val as initial value + elif isinstance(init, tuple) or isinstance(init, int): + self.manager.registerVar( + self.name, + init[0], + init[2], + numVectors=1, + errBoundMode="ABS", + compType="sz3", + errBound=1e-5, + ) + self.manager.compress(np.full(init[0], fill_value=val), self.name, 0) + # something is wrong, if none of the ones above hit + else: + raise DataError("something went wrong during %s initialization" % type(self)) + + def __del__(self): + print("Delete" + " " + self.name) + self.manager.remove(self.name, 0) + + def __add__(self, other): + """ + Overloading the addition operator for mesh types + + Args: + other (mesh.mesh): mesh object to be added + Raises: + DataError: if other is not a mesh object + Returns: + mesh.mesh: sum of caller and other values (self+other) + """ + + if isinstance(other, compressed_meshV2): + # always create new mesh, since otherwise c = a + b changes a as well! + me = compressed_meshV2(self) + values = self.manager.decompress(self.name, 0) + ov = self.manager.decompress(other.name, 0) + self.manager.compress(values + ov, me.name, 0) + return me + else: + raise DataError("Type error: cannot add %s to %s" % (type(other), type(self))) + + def __sub__(self, other): + """ + Overloading the subtraction operator for mesh types + + Args: + other (mesh.mesh): mesh object to be subtracted + Raises: + DataError: if other is not a mesh object + Returns: + mesh.mesh: differences between caller and other values (self-other) + """ + + if isinstance(other, compressed_meshV2): + # always create new mesh, since otherwise c = a - b changes a as well! + me = compressed_meshV2(self) + values = self.manager.decompress(self.name, 0) + ov = self.manager.decompress(other.name, 0) + self.manager.compress(values - ov, me.name, 0) + return me + else: + raise DataError("Type error: cannot subtract %s from %s" % (type(other), type(self))) + + def __rmul__(self, other): + """ + Overloading the right multiply by factor operator for mesh types + + Args: + other (float): factor + Raises: + DataError: is other is not a float + Returns: + mesh.mesh: copy of original values scaled by factor + """ + + if isinstance(other, float) or isinstance(other, complex): + # always create new mesh, since otherwise c = f*a changes a as well! + values = self.manager.decompress(self.name, 0) + me = compressed_meshV2(self) + self.manager.compress(values * other, me.name, 0) + return me + else: + raise DataError("Type error: cannot multiply %s to %s" % (type(other), type(self))) + + def __abs__(self): + """ + Overloading the abs operator for mesh types + + Returns: + float: absolute maximum of all mesh values + """ + + # take absolute values of the mesh values + values = self.manager.decompress(self.name, 0) + absval = abs(values) + + # return maximum + return np.amax(absval) + + def __setitem__(self, key, newvalue): + print("SET: ", key, newvalue) + if type(newvalue) == type(self): # Assigning compressed mesh + arr_temp = self.manager.decompress(newvalue.name, 0) + self.manager.compress(arr_temp, self.name, 0) + else: + array = self.manager.decompress(self.name, 0) + array.__setitem__(key, newvalue) + self.manager.compress(array, self.name, 0) + + def __getitem__(self, key): + array = self.manager.decompress(self.name, 0) + return array.__getitem__(key) + + def __str__(self): + return str(self[:]) + + +''' + def apply_mat(self, A): + """ + Matrix multiplication operator + + Args: + A: a matrix + + Returns: + mesh.mesh: component multiplied by the matrix A + """ + if not A.shape[1] == self.values.shape[0]: + raise DataError("ERROR: cannot apply operator %s to %s" % (A.shape[1], self)) + + me = mesh(A.shape[0]) + me.values = A.dot(self.values) + + return me + + def isend(self, dest=None, tag=None, comm=None): + """ + Routine for sending data forward in time (non-blocking) + + Args: + dest (int): target rank + tag (int): communication tag + comm: communicator + + Returns: + request handle + """ + return comm.Issend(self.values[:], dest=dest, tag=tag) + + def irecv(self, source=None, tag=None, comm=None): + """ + Routine for receiving in time + + Args: + source (int): source rank + tag (int): communication tag + comm: communicator + + Returns: + None + """ + return comm.Irecv(self.values[:], source=source, tag=tag) + + def bcast(self, root=None, comm=None): + """ + Routine for broadcasting values + + Args: + root (int): process with value to broadcast + comm: communicator + + Returns: + broadcasted values + """ + return comm.bcast(self, root=root) +''' + + +N = 30 +init = (N, None, np.dtype("float64")) +a = compressed_meshV2(init) +# a1 = compressed_mesh(init, varName='A') +b = compressed_meshV2(init) +c = compressed_meshV2(init) +a[:] = 1 +b[:] = 2 +print(a) +print(b) +c[:] = a + b +print(type(a + b)) +print(type(c)) +print(c[:]) +print(c.name) +print(a.manager) +del a +print(b.manager) diff --git a/pySDC/playgrounds/compression/heat_compressed.py b/pySDC/playgrounds/compression/heat_compressed.py new file mode 100644 index 0000000000..7077af8769 --- /dev/null +++ b/pySDC/playgrounds/compression/heat_compressed.py @@ -0,0 +1,11 @@ +from pySDC.implementations.problem_classes.HeatEquation_ND_FD import heatNd_unforced +from pySDC.implementations.problem_classes.HeatEquation_ND_FD import heatNd_forced +from pySDC.playgrounds.compression.compressed_mesh import ( + compressed_mesh, + imex_mesh_compressed, +) + + +class heat_ND_compressed(heatNd_forced): + dtype_f = imex_mesh_compressed + dtype_u = compressed_mesh diff --git a/pySDC/playgrounds/compression/heat_example.py b/pySDC/playgrounds/compression/heat_example.py new file mode 100644 index 0000000000..be63531646 --- /dev/null +++ b/pySDC/playgrounds/compression/heat_example.py @@ -0,0 +1,82 @@ +from pySDC.implementations.problem_classes.HeatEquation_ND_FD import heatNd_forced +from pySDC.implementations.sweeper_classes.imex_1st_order import imex_1st_order +from pySDC.implementations.controller_classes.controller_MPI import controller_MPI +from pySDC.implementations.controller_classes.controller_nonMPI import controller_nonMPI +from pySDC.helpers.stats_helper import get_sorted +from mpi4py import MPI +from pySDC.implementations.hooks.log_errors import LogGlobalErrorPostRun +from pySDC.implementations.hooks.log_solution import LogSolution +from pySDC.playgrounds.compression.heat_compressed import heat_ND_compressed + + +def run_heat(Tend=1): + # setup communicator + # comm = MPI.COMM_WORLD if comm is None else comm + + # initialize problem parameters + problem_params = {} + problem_params["nu"] = 1 + problem_params["freq"] = (4, 4, 4) + problem_params["order"] = 4 + problem_params["lintol"] = 1e-7 + problem_params["liniter"] = 99 + problem_params["solver_type"] = "CG" + problem_params["nvars"] = (32, 32, 32) # Have to be the same, Nx = Ny = Nz + problem_params["bc"] = "periodic" + + # initialize level parameters + level_params = {} + level_params["restol"] = 5e-04 + level_params["dt"] = 1e-01 + level_params["nsweeps"] = 1 + + # initialize sweeper parameters + sweeper_params = {} + sweeper_params["node_type"] = "LEGENDRE" + sweeper_params["quad_type"] = "RADAU-RIGHT" + sweeper_params["QI"] = ["IE"] + sweeper_params["QE"] = ["PIC"] + sweeper_params["num_nodes"] = 3 + sweeper_params["initial_guess"] = "spread" + + # initialize step parameters + step_params = {} + step_params["maxiter"] = 50 + + # initialize controller parameters + controller_params = {} + controller_params["logger_level"] = 15 + controller_params["hook_class"] = [LogSolution, LogGlobalErrorPostRun] + + # fill description dictionary for easy step instantiation + description = {} + # description['problem_class'] = heatNd_forced# heat_ND_compressed + description["problem_class"] = heat_ND_compressed + description["problem_params"] = problem_params + description["sweeper_class"] = imex_1st_order + description["sweeper_params"] = sweeper_params + description["level_params"] = level_params + description["step_params"] = step_params + + # instantiate controller + controller = controller_nonMPI(controller_params=controller_params, description=description, num_procs=1) + + # get initial values on finest level + P = controller.MS[0].levels[0].prob + uinit = P.u_exact(0.0) + + # call main function to get things done... + uend, stats = controller.run(u0=uinit, t0=0.0, Tend=Tend) + + return stats + + +def main(): + stats = run_heat(Tend=1) + error = max([me[1] for me in get_sorted(stats, type="e_global_post_run")]) + # u = get_sorted(stats, type="u") + print(error) + + +if __name__ == "__main__": + main() diff --git a/pySDC/projects/compression/AllenCahn_MPIFFT.py b/pySDC/projects/compression/AllenCahn_MPIFFT.py new file mode 100644 index 0000000000..ec465b735e --- /dev/null +++ b/pySDC/projects/compression/AllenCahn_MPIFFT.py @@ -0,0 +1,282 @@ +import numpy as np +from mpi4py import MPI +from mpi4py_fft import PFFT + +from pySDC.core.Errors import ProblemError +from pySDC.core.Problem import ptype +from pySDC.implementations.datatype_classes.mesh import mesh, imex_mesh + +from mpi4py_fft import newDistArray + + +class allencahn_imex(ptype): + """ + Example implementing Allen-Cahn equation in 2-3D using mpi4py-fft for solving linear parts, IMEX time-stepping + + mpi4py-fft: https://mpi4py-fft.readthedocs.io/en/latest/ + + Attributes: + fft: fft object + X: grid coordinates in real space + K2: Laplace operator in spectral space + dx: mesh width in x direction + dy: mesh width in y direction + """ + + dtype_u = mesh + dtype_f = imex_mesh + + def __init__(self, nvars, eps, radius, spectral, dw=0.0, L=1.0, init_type="circle", comm=None): + """ + Initialization routine + + Args: + problem_params (dict): custom parameters for the example + dtype_u: fft data type (will be passed to parent class) + dtype_f: fft data type wuth implicit and explicit parts (will be passed to parent class) + """ + if not (isinstance(nvars, tuple) and len(nvars) > 1): + raise ProblemError("Need at least two dimensions") + + # Creating FFT structure + ndim = len(nvars) + axes = tuple(range(ndim)) + self.fft = PFFT(comm, list(nvars), axes=axes, dtype=np.float64, collapse=True) + + # get test data to figure out type and dimensions + tmp_u = newDistArray(self.fft, spectral) + + # invoke super init, passing the communicator and the local dimensions as init + super().__init__(init=(tmp_u.shape, comm, tmp_u.dtype)) + self._makeAttributeAndRegister( + "nvars", + "eps", + "radius", + "spectral", + "dw", + "L", + "init_type", + "comm", + localVars=locals(), + readOnly=True, + ) + + L = np.array([self.L] * ndim, dtype=float) + + # get local mesh + X = np.ogrid[self.fft.local_slice(False)] + N = self.fft.global_shape() + for i in range(len(N)): + X[i] = X[i] * L[i] / N[i] + self.X = [np.broadcast_to(x, self.fft.shape(False)) for x in X] + + # get local wavenumbers and Laplace operator + s = self.fft.local_slice() + N = self.fft.global_shape() + k = [np.fft.fftfreq(n, 1.0 / n).astype(int) for n in N[:-1]] + k.append(np.fft.rfftfreq(N[-1], 1.0 / N[-1]).astype(int)) + K = [ki[si] for ki, si in zip(k, s)] + Ks = np.meshgrid(*K, indexing="ij", sparse=True) + Lp = 2 * np.pi / L + for i in range(ndim): + Ks[i] = (Ks[i] * Lp[i]).astype(float) + K = [np.broadcast_to(k, self.fft.shape(True)) for k in Ks] + K = np.array(K).astype(float) + self.K2 = np.sum(K * K, 0, dtype=float) + + # Need this for diagnostics + self.dx = self.L / nvars[0] + self.dy = self.L / nvars[1] + + def eval_f(self, u, t): + """ + Routine to evaluate the RHS + + Args: + u (dtype_u): current values + t (float): current time + + Returns: + dtype_f: the RHS + """ + + f = self.dtype_f(self.init) + + if self.spectral: + f.impl = -self.K2 * u + + if self.eps > 0: + tmp = self.fft.backward(u) + tmpf = -2.0 / self.eps**2 * tmp * (1.0 - tmp) * (1.0 - 2.0 * tmp) - 6.0 * self.dw * tmp * (1.0 - tmp) + f.expl[:] = self.fft.forward(tmpf) + + else: + u_hat = self.fft.forward(u) + lap_u_hat = -self.K2 * u_hat + f.impl[:] = self.fft.backward(lap_u_hat, f.impl) + + if self.eps > 0: + f.expl = -2.0 / self.eps**2 * u * (1.0 - u) * (1.0 - 2.0 * u) - 6.0 * self.dw * u * (1.0 - u) + + return f + + def solve_system(self, rhs, factor, u0, t): + """ + Simple FFT solver for the diffusion part + + Args: + rhs (dtype_f): right-hand side for the linear system + factor (float) : abbrev. for the node-to-node stepsize (or any other factor required) + u0 (dtype_u): initial guess for the iterative solver (not used here so far) + t (float): current time (e.g. for time-dependent BCs) + + Returns: + dtype_u: solution as mesh + """ + + if self.spectral: + me = rhs / (1.0 + factor * self.K2) + + else: + me = self.dtype_u(self.init) + rhs_hat = self.fft.forward(rhs) + rhs_hat /= 1.0 + factor * self.K2 + me[:] = self.fft.backward(rhs_hat) + + return me + + def u_exact(self, t): + """ + Routine to compute the exact solution at time t + + Args: + t (float): current time + + Returns: + dtype_u: exact solution + """ + + assert t == 0, "ERROR: u_exact only valid for t=0" + me = self.dtype_u(self.init, val=0.0) + if self.init_type == "circle": + r2 = (self.X[0] - 0.5) ** 2 + (self.X[1] - 0.5) ** 2 + if self.spectral: + tmp = 0.5 * (1.0 + np.tanh((self.radius - np.sqrt(r2)) / (np.sqrt(2) * self.eps))) + me[:] = self.fft.forward(tmp) + else: + me[:] = 0.5 * (1.0 + np.tanh((self.radius - np.sqrt(r2)) / (np.sqrt(2) * self.eps))) + elif self.init_type == "circle_rand": + ndim = len(me.shape) + L = int(self.L) + # get random radii for circles/spheres + np.random.seed(1) + lbound = 3.0 * self.eps + ubound = 0.5 - self.eps + rand_radii = (ubound - lbound) * np.random.random_sample(size=tuple([L] * ndim)) + lbound + # distribute circles/spheres + tmp = newDistArray(self.fft, False) + if ndim == 2: + for i in range(0, L): + for j in range(0, L): + # build radius + r2 = (self.X[0] + i - L + 0.5) ** 2 + (self.X[1] + j - L + 0.5) ** 2 + # add this blob, shifted by 1 to avoid issues with adding up negative contributions + tmp += np.tanh((rand_radii[i, j] - np.sqrt(r2)) / (np.sqrt(2) * self.eps)) + 1 + # normalize to [0,1] + tmp *= 0.5 + assert np.all(tmp <= 1.0) + if self.spectral: + me[:] = self.fft.forward(tmp) + else: + me[:] = tmp[:] + else: + raise NotImplementedError("type of initial value not implemented, got %s" % self.init_type) + + return me + + +class allencahn_imex_timeforcing(allencahn_imex): + """ + Example implementing Allen-Cahn equation in 2-3D using mpi4py-fft for solving linear parts, IMEX time-stepping, + time-dependent forcing + """ + + def eval_f(self, u, t): + """ + Routine to evaluate the RHS + + Args: + u (dtype_u): current values + t (float): current time + + Returns: + dtype_f: the RHS + """ + + f = self.dtype_f(self.init) + + if self.spectral: + f.impl = -self.K2 * u + + tmp = newDistArray(self.fft, False) + tmp[:] = self.fft.backward(u, tmp) + + if self.eps > 0: + tmpf = -2.0 / self.eps**2 * tmp * (1.0 - tmp) * (1.0 - 2.0 * tmp) + else: + tmpf = self.dtype_f(self.init, val=0.0) + + # build sum over RHS without driving force + Rt_local = float(np.sum(self.fft.backward(f.impl) + tmpf)) + if self.comm is not None: + Rt_global = self.comm.allreduce(sendobj=Rt_local, op=MPI.SUM) + else: + Rt_global = Rt_local + + # build sum over driving force term + Ht_local = float(np.sum(6.0 * tmp * (1.0 - tmp))) + if self.comm is not None: + Ht_global = self.comm.allreduce(sendobj=Ht_local, op=MPI.SUM) + else: + Ht_global = Rt_local + + # add/substract time-dependent driving force + if Ht_global != 0.0: + dw = Rt_global / Ht_global + else: + dw = 0.0 + + tmpf -= 6.0 * dw * tmp * (1.0 - tmp) + f.expl[:] = self.fft.forward(tmpf) + + else: + u_hat = self.fft.forward(u) + lap_u_hat = -self.K2 * u_hat + f.impl[:] = self.fft.backward(lap_u_hat, f.impl) + + if self.eps > 0: + f.expl = -2.0 / self.eps**2 * u * (1.0 - u) * (1.0 - 2.0 * u) + + # build sum over RHS without driving force + Rt_local = float(np.sum(f.impl + f.expl)) + if self.comm is not None: + Rt_global = self.comm.allreduce(sendobj=Rt_local, op=MPI.SUM) + else: + Rt_global = Rt_local + + # build sum over driving force term + Ht_local = float(np.sum(6.0 * u * (1.0 - u))) + if self.comm is not None: + Ht_global = self.comm.allreduce(sendobj=Ht_local, op=MPI.SUM) + else: + Ht_global = Rt_local + + # add/substract time-dependent driving force + if Ht_global != 0.0: + dw = Rt_global / Ht_global + else: + dw = 0.0 + + f.expl -= 6.0 * dw * u * (1.0 - u) + + return f diff --git a/pySDC/projects/compression/CRAM_Manager.py b/pySDC/projects/compression/CRAM_Manager.py index a829f7f66c..21720af390 100644 --- a/pySDC/projects/compression/CRAM_Manager.py +++ b/pySDC/projects/compression/CRAM_Manager.py @@ -1,30 +1,55 @@ -# python class that calls c functions to handle compression/decompression import numpy as np np.bool = np.bool_ import libpressio from pySDC.implementations.datatype_classes.mesh import mesh +from pySDC.projects.compression.cache_manager import Cache + +from time import time +import os class CRAM_Manager: + # Cache attribute: + cacheManager = Cache() + # constructor - def __init__(self, errBoundMode="ABS", compType="sz3", errBound=1e-5): - # print("constructor called!") - # if self.init = 0 + # def __init__(self, errBoundMode="PW_REL", compType="sz3", errBound=1e-5): + def __init__(self, errBoundMode="PW_REL", compType="blosc", errBound=1e-5, losslesscompressor="zstd"): + # Parameters for the error bound and compressor self.errBoundMode = errBoundMode self.errBound = errBound self.compType = compType + self.losslesscompressor = losslesscompressor + # Parameters for memory map and cache (bool to enable logging cache history as well) self.mem_map = {} - self.cache = {} - self.max_cache_size = 30 - # self.init = 1 + self.cacheHist = [] + self.trackBaseline = True + self.logcacheHist = False + self.cachePolicy = ['LRU', 'LFU'] + # Parameters to compute and store metrics + self.registerVars_time = 0 + self.compression_time_nocache = 0 # No cache, compression time + self.compression_time = 0 # Not found in cache, compression, write back eviction maybe and put time + self.compression_time_update = 0 # Found in cache, only update decompressed data time + self.compression_time_eviction = 0 # write back cache eviction time + self.compression_time_put_only = 0 # compression - put time + self.decompression_time_nocache = 0 # No cache, decompression time + self.decompression_time = 0 # Not found in cache, decompression, write back eviction maybe and put time + self.decompression_time_get = 0 # Found in cache, get (retrieve it) + self.decompression_time_eviction = 0 # write back cache eviction time + self.decompression_time_put_only = 0 # decompression - put time + self.num_registered_var = 0 + self.num_active_registered_var = 0 + self.num_compression_calls = 0 + self.num_decompression_calls = 0 self.name = 0 # TODO: update registration to return name # destructor def __del__(self): pass - # numVectors is M + # Registers array to be compressed, decompressed in memory map if it does not already exists and updates number of registrations def registerVar( self, varName, @@ -34,11 +59,13 @@ def registerVar( errBoundMode=None, compType=None, errBound=None, + losslesscompressor=None, ): + start_time = time() if varName not in self.mem_map: # print("Register: ", varName, "-", shape, len(self.mem_map.keys())) compressor = libpressio.PressioCompressor.from_config( - self.generate_compressor_config(compType, errBoundMode, errBound) + self.generate_compressor_config(compType, errBoundMode, errBound, losslesscompressor) ) self.mem_map[varName] = [ @@ -47,87 +74,286 @@ def registerVar( shape, ] # TODO finish + self.num_registered_var += 1 + self.num_active_registered_var += 1 + end_time = time() + time_diff = end_time - start_time + self.registerVars_time += time_diff + # Register array flag here + if self.logcacheHist: + self.cacheHist.append('Registered array (Mem map) ' + varName) + def remove(self, name, index): - self.cache.pop(name + "_" + str(index), None) + self.cacheManager.cache.pop(name + "_" + str(index), None) + self.cacheManager.cacheFrequency.pop(name + "_" + str(index), None) + key_list = list(self.cacheManager.countCache.keys()) + value_list = list(self.cacheManager.countCache.values()) + idx = 0 + flag = False + for values in value_list: + idx += 1 + for value in values: + if (name + "_" + str(index)) == value: + flag = True + break + if flag: + break + try: + if flag: + self.cacheManager.countCache[key_list[idx - 1]].remove(name + "_" + str(index)) + if not self.cacheManager.countCache[key_list[idx - 1]]: + self.cacheManager.countCache.pop(key_list[idx - 1], None) + except: + print(self.cacheManager.cache) + print(self.cacheManager.countCache) + print(self.cacheManager.countCache[key_list[idx - 1]]) + print(key_list) + print(key_list[idx - 1]) + print(self.cacheManager.countCache[key_list[idx - 1]]) + print(name + "_" + str(index)) + print(self.mem_map) + os._exit(1) + self.mem_map.pop(name, None) + self.num_active_registered_var -= 1 + + # Add log to deregister + if self.logcacheHist: + self.cacheHist.append('Deregistered array (Mem map) ' + name) def compress( - self, data, varName, index, errBoundMode="ABS", compType="sz3", errBound=None + self, data, varName, index, errBoundMode="PW_REL", compType="blosc", errBound=None, losslesscompressor="zstd" ): # print("Cprss: ", varName, index) # print("Array: ", data) # print("Error bound: ",errBound) - if errBound is not None: - compressor = libpressio.PressioCompressor.from_config( - self.generate_compressor_config(compType, errBoundMode, errBound) - ) - # cfg = compressor.get_config() - # print(errBound) - # cfg['compressor_config']['pressio:abs'] = errBound + if self.trackBaseline: + start_time = time() + if errBound is not None: + compressor = libpressio.PressioCompressor.from_config( + self.generate_compressor_config(compType, errBoundMode, errBound, losslesscompressor) + ) + + self.mem_map[varName][0] = compressor + else: + compressor = self.mem_map[varName][0] + + # Compress data + self.mem_map[varName][1][index] = compressor.encode(data) + end_time = time() + + # Log array if logging is on + if self.logcacheHist: + self.cacheHist.append('Added array: ' + varName) + self.cacheHist.append('Compressed array (Store) ' + varName) + + # Log compression time and compression calls metrics + time_diff = end_time - start_time + self.compression_time_nocache += time_diff + self.num_compression_calls += 1 + + elif self.cacheName(varName, index) not in self.cacheManager.cache: + self.cacheManager.cache_misses += 1 + start_time = time() + if errBound is not None: + compressor = libpressio.PressioCompressor.from_config( + self.generate_compressor_config(compType, errBoundMode, errBound, losslesscompressor) + ) + + self.mem_map[varName][0] = compressor + else: + compressor = self.mem_map[varName][0] + # Compress data + self.mem_map[varName][1][index] = compressor.encode(data) + + # If cache is full, get array name for array which will be evicted and update mem_map (write back cache) + start_time3 = time() + if len(self.cacheManager.cache) + 1 > self.cacheManager.cacheSize: + minKey = min(self.cacheManager.countCache.keys()) + evictArray = self.cacheManager.countCache[minKey][0] + self.mem_map[evictArray.split('_')[0]][1][index] = compressor.encode( + self.cacheManager.cache[evictArray] + ) + # Add logging for array evicted if logging cache history is on + if self.logcacheHist: + self.cacheHist.append('Evicted array ' + evictArray.split('_')[0]) + end_time3 = time() + self.compression_time_eviction += end_time3 - start_time3 + + # Add to cache + start_time2 = time() + self.cacheManager.put(self.cacheName(varName, index), data) + end_time2 = time() + self.compression_time_put_only += end_time2 - start_time2 + + end_time = time() + + # Add logging for the array to be added and then in compressed state if logging cache history is on + if self.logcacheHist: + self.cacheHist.append('Added array: ' + varName) + self.cacheHist.append('Compressed array (Store) ' + varName) + + # Log compression time and compression calls metrics + time_diff = end_time - start_time + self.compression_time += time_diff + self.num_compression_calls += 1 - # compressor.set_config(cfg) - self.mem_map[varName][0] = compressor else: - compressor = self.mem_map[varName][0] - # print(compressor.get_config()['compressor_id']) - # print(compressor.get_config()['compressor_config']) - self.mem_map[varName][1][index] = compressor.encode(data) - self.cache.pop(self.cacheName(varName, index), None) + self.cacheManager.cache_hits += 1 + start_time = time() + combineName = self.cacheName(varName, index) + self.cacheManager.cache[combineName] = data # Dictionary access + prev_count = self.cacheManager.cacheFrequency[combineName] + self.cacheManager.cacheFrequency[combineName] += 1 # Dictionary access + count = self.cacheManager.cacheFrequency[combineName] + self.cacheManager.countCache[prev_count].remove(combineName) + if not self.cacheManager.countCache[prev_count]: + self.cacheManager.countCache.pop(prev_count, None) + if count not in self.cacheManager.countCache.keys(): + self.cacheManager.countCache[count] = [] + self.cacheManager.countCache[count].append(combineName) + else: + self.cacheManager.countCache[count].append(combineName) + end_time = time() + + # Log array if logging is on + if self.logcacheHist: + self.cacheHist.append('Updated array ' + varName) + + # Log compression time and compression calls metrics + time_diff = end_time - start_time + self.compression_time_update += time_diff def cacheName(self, varName, index): return varName + "_" + str(index) def decompress(self, varName, index, compType=0): # print("Decprss: ", varName, index) + combineName = self.cacheName(varName, index) - if combineName not in self.cache: + + # Decompress array from main memory and return it if no cache mechanism + if self.trackBaseline: + start_time = time() compressor = self.mem_map[varName][0] comp_data = self.mem_map[varName][1][index] decomp_data = np.zeros(self.mem_map[varName][2]) - # if comp_data != None: + # Get decompressed values of the compressed array tmp = compressor.decode(comp_data, decomp_data) - - if ( - len(self.cache) + 1 > self.max_cache_size - ): # TODO: Add LRU replacement policy - k = list(self.cache.keys())[0] - self.cache.pop(k) - self.cache[combineName] = tmp + end_time = time() + # Log decompression time and decompression calls metrics + time_diff = end_time - start_time + self.decompression_time_nocache += time_diff + self.num_decompression_calls += 1 + # Log cache history if enabled + if self.logcacheHist: + self.cacheHist.append('Decompressed array (Load) ' + varName) return tmp - # else: - # tmp = decomp_data + if combineName not in self.cacheManager.cache: + self.cacheManager.cache_misses += 1 + start_time = time() + compressor = self.mem_map[varName][0] + comp_data = self.mem_map[varName][1][index] + decomp_data = np.zeros(self.mem_map[varName][2]) + + # Get decompressed values of the compressed array + tmp = compressor.decode(comp_data, decomp_data) + + # If cache was full, get array name for array which was evicted and update mem_map (write back cache) + start_time3 = time() + if len(self.cacheManager.cache) + 1 > self.cacheManager.cacheSize: + try: + minKey = min(self.cacheManager.countCache.keys()) + evictArray = self.cacheManager.countCache[minKey][0] + self.mem_map[evictArray.split('_')[0]][1][index] = compressor.encode( + self.cacheManager.cache[evictArray] + ) + # Add logging for array evicted if logging cache history is on + if self.logcacheHist: + self.cacheHist.append('Evicted array ' + evictArray.split('_')[0]) + except: + print(self.cacheManager.cacheSize) + print(len(self.cacheManager.cache)) + print(self.cacheManager.cache) + print(self.cacheManager.cacheFrequency) + print(self.cacheManager.countCache) + os._exit(1) + end_time3 = time() + self.decompression_time_eviction += end_time3 - start_time3 + + # Add the array to the cache + start_time2 = time() + self.cacheManager.put(combineName, tmp) + end_time2 = time() + self.decompression_time_put_only += end_time2 - start_time2 + + end_time = time() + + # Log history that array is added if logging cache history is on + if self.logcacheHist: + self.cacheHist.append('Added array to cache: ' + varName) + self.cacheHist.append('Decompressed array (Load) ' + varName) + + # Log decompression time and decompression calls metrics + time_diff = end_time - start_time + self.decompression_time += time_diff + self.num_decompression_calls += 1 + return tmp - tmp_mesh = mesh(self.mem_map[varName][2]) - tmp_mesh[:] = tmp + # tmp_mesh = mesh(self.mem_map[varName][2]) + # tmp_mesh[:] = tmp else: # print ("Found in Cache") - return self.cache[combineName] + self.cacheManager.cache_hits += 1 + start_time = time() + decomp_array = self.cacheManager.get(combineName) + end_time = time() - def set_global_compressor_config( - self, compType=None, errBoundMode=None, errBound=None - ): + # Log decompression time and decompression calls metrics + time_diff = end_time - start_time + self.decompression_time_get += time_diff + + # Log cache history if enabled + if self.logcacheHist: + self.cacheHist.append('Decompressed array (Load) ' + varName) + return decomp_array + + def set_global_compressor_config(self, compType=None, errBoundMode=None, errBound=None, losslesscompressor=None): self.compType = self.compType if compType is None else compType self.errBoundMode = self.errBoundMode if errBoundMode is None else errBoundMode self.errBound = self.errBound if errBound is None else errBound + self.losslesscompressor = self.losslesscompressor if losslesscompressor is None else losslesscompressor for k in self.mem_map: self.mem_map[k][0] = libpressio.PressioCompressor.from_config( self.generate_compressor_config( - self.compType, self.errBoundMode, self.errBound + self.compType, self.errBoundMode, self.errBound, self.losslesscompressor ) ) - def generate_compressor_config( - self, compType=None, errBoundMode=None, errBound=None - ): + def generate_compressor_config(self, compType=None, errBoundMode=None, errBound=None, losslesscompressor=None): compType = self.compType if compType is None else compType errBoundMode = self.errBoundMode if errBoundMode is None else errBoundMode errBound = self.errBound if errBound is None else errBound + losslesscompressor = self.losslesscompressor if losslesscompressor is None else losslesscompressor # print('Error bound: ',errBound) + # return { + # # configure which compressor to use + # "compressor_id": compType, + # # configure the set of metrics to be gathered + # "early_config": { + # "pressio:metric": "composite", + # "composite:plugins": ["time", "size", "error_stat"], + # }, + # # configure SZ + # "compressor_config": { + # "pressio:abs": errBound, + # }, + # } return { # configure which compressor to use - "compressor_id": compType, + "compressor_id": "blosc", # configure the set of metrics to be gathered "early_config": { "pressio:metric": "composite", @@ -135,7 +361,7 @@ def generate_compressor_config( }, # configure SZ "compressor_config": { - "pressio:abs": errBound, + "blosc:compressor": "zstd", }, } @@ -151,34 +377,69 @@ def __str__(self): return s - # def printStats(self, varName, index=0): - # print(" ") #for readability - # sz_class.sz_printVarInfo(varName) - def getStats(self, varName, index=0): compressor = self.mem_map[varName][0] return compressor.get_metrics() + # Calculate compression ratio for all arrays stored in main memory and cache + def sumCompressionRatio(self): + keys_memmap = self.mem_map.keys() + if not self.trackBaseline: + list_keys = self.cacheManager.cache.keys() + sumTotalSize = 0 + sumCompSize = 0 + sumCacheDecompSize = 0 + # sumCR = [] + + # Get total size of all arrays in main memory and size of all compressed arrays in main memory + for k in keys_memmap: + sumTotalSize += self.getStats(k, 0)['size:uncompressed_size'] + sumCompSize += self.getStats(k, 0)['size:compressed_size'] + + # Get total size of all arrays in cache + if not self.trackBaseline: + for key in list_keys: + key = key.split('_')[0] + sumCacheDecompSize += self.getStats(key, 0)['size:uncompressed_size'] + return sumTotalSize / (sumCompSize + sumCacheDecompSize) + + def getWrapperTime(self): + return self.registerVars_time + self.compression_time + self.decompression_time + if __name__ == "__main__": arr = np.random.rand(100, 100) # declare global instance of memory - memory = CRAM_Manager(errBoundMode="ABS", compType="sz3", errBound=1e-5) + memory = CRAM_Manager(errBoundMode="PW_REL", compType="sz3", errBound=1e-5) memory.registerVar( "cat", arr.shape, dtype=np.dtype("float64"), numVectors=1, - errBoundMode="ABS", + errBoundMode="PW_REL", compType="sz3", errBound=0.1, ) memory.compress(arr, "cat", 0) - result = memory.decompress("cat", 0, shape=arr.shape) + result = memory.decompress("cat", 0) print(arr) print("\n") print(result) print("\n") error = arr - result print(error) + print("\n") + print("Cache History\n") + print(memory.cacheHist) + print("\nCache\n") + print(memory.cacheManager.cache) + print("Cache History\n") + print(memory.cacheHist) + print("\nCache\n") + print(memory.cacheManager.cache) + print(memory.sumCompressionRatio()) + +# implement cache replacement policy +# LFU - use a counter for that array and then based on that counter when it comes to evict, choose the minimum counter and evict it +# Also write back cache diff --git a/pySDC/projects/compression/Untitled.ipynb b/pySDC/projects/compression/Untitled.ipynb new file mode 100644 index 0000000000..7785b8737a --- /dev/null +++ b/pySDC/projects/compression/Untitled.ipynb @@ -0,0 +1,895 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "c12920b8-cae8-45f0-8131-ffacf168f1fa", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import os\n", + "import re\n", + "import sys\n", + "import random\n", + "import time\n", + "import glob\n", + "import pandas as pd\n", + "import csv\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "sns.set_theme(style=\"whitegrid\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "c6a37607-ad69-4ad7-bc70-3dbe626d2093", + "metadata": {}, + "outputs": [], + "source": [ + "data_frame1 = pd.read_csv('result_cache_size_he_0_nolog_blosc.csv',index_col='Time Steps')\n", + "data_frame1[\"Normalized Compression Calls\"] = data_frame1[\"Compression Calls\"]/data_frame1[\"Number of iterations\"]\n", + "data_frame1[\"Normalized Decompression Calls\"] = data_frame1[\"Decompression Calls\"]/data_frame1[\"Number of iterations\"]\n", + "data_frame2 = pd.read_csv('result_cache_size_he_1_nolog_blosc.csv',index_col='Time Steps')\n", + "data_frame3 = pd.read_csv('result_cache_size_he_2_nolog_blosc.csv',index_col='Time Steps')\n", + "data_frame4 = pd.read_csv('result_cache_size_he_4_nolog_blosc.csv',index_col='Time Steps')\n", + "data_frame5 = pd.read_csv('result_cache_size_he_7_nolog_blosc.csv',index_col='Time Steps')\n", + "data_frame6 = pd.read_csv('result_cache_size_he_11_nolog_blosc.csv',index_col='Time Steps')\n", + "all_data_frames = [data_frame1,data_frame2,data_frame3,data_frame4,data_frame5,data_frame6]\n", + "for i in all_data_frames:\n", + " i[\"Normalized Compression Calls\"] = i[\"Compression Calls\"]/i[\"Number of iterations\"]\n", + " i[\"Normalized Decompression Calls\"] = i[\"Decompression Calls\"]/i[\"Number of iterations\"]\n", + " i[\"Compression Time (Cache compress)\"] = i[\"Compression Time (Cache)\"]-(i[\"Compression Time (Evictions)\"]+i[\"Compression Time (Put)\"])\n", + " i[\"Decompression Time (Cache decompress)\"] = i[\"Decompression Time (Cache)\"]-(i[\"Decompression Time (Evictions)\"]+i[\"Decompression Time (Put)\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "3231c954-30a2-4f75-96aa-facaf3217689", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Compression CallsDecompression CallsCompression Time (No Cache)Compression Time (Cache)Compression Time (Evictions)Compression Time (Put)Compression Time (Update)Decompression Time (No Cache)Decompression Time (Cache)Decompression Time (Evictions)Decompression Time (Put)Decompression Time (Get)Total Time (compression)Total Time (decompression)Cache InvalidatesNumber of iterationsNormalized Compression CallsNormalized Decompression CallsCompression Time (Cache compress)Decompression Time (Cache decompress)
Time Steps
0.1150657902.7690950.8027420.0102040.00513801.7125820.3449490.0029330.0066062.7742341.7191889148188.25000072.3751.9561501.364701
0.2201795504.0682631.4011540.0138100.00568003.1383990.7153040.0050520.0077484.0739443.146147161210201.70000095.5002.6532992.418043
0.3201795504.1061741.4099920.0122710.00515503.1454180.7528680.0044650.0074684.1113293.152886161210201.70000095.5002.6839112.388085
0.4201795504.2387591.4656740.0115880.00487503.1618240.7546010.0043720.0073954.2436343.169218161210201.70000095.5002.7614972.402851
0.5201795504.0703991.3901000.0112970.00477203.1783700.7810970.0042800.0073744.0751713.185745161210201.70000095.5002.6690012.392993
0.6201795504.1771441.5117650.0110770.00474903.1058640.7573710.0043030.0073184.1818933.113181161210201.70000095.5002.6543022.344191
0.72218105604.4281341.5110290.0135180.00558603.3520160.8196360.0050800.0083444.4337203.360361178311201.63636496.0002.9035862.527301
0.82218105604.5531631.5342960.0127910.00552503.4419770.8675950.0049030.0082364.5586873.450213178311201.63636496.0003.0060752.569479
0.92218105604.7703531.6491690.0127880.00551303.5745880.9006000.0049440.0084694.7758673.583056178311201.63636496.0003.1083962.669043
1.02218105604.5766631.5954510.0126770.00524603.4288490.8585530.0049230.0079834.5819103.436832178311201.63636496.0002.9685352.565373
\n", + "
" + ], + "text/plain": [ + " Compression Calls Decompression Calls \\\n", + "Time Steps \n", + "0.1 1506 579 \n", + "0.2 2017 955 \n", + "0.3 2017 955 \n", + "0.4 2017 955 \n", + "0.5 2017 955 \n", + "0.6 2017 955 \n", + "0.7 2218 1056 \n", + "0.8 2218 1056 \n", + "0.9 2218 1056 \n", + "1.0 2218 1056 \n", + "\n", + " Compression Time (No Cache) Compression Time (Cache) \\\n", + "Time Steps \n", + "0.1 0 2.769095 \n", + "0.2 0 4.068263 \n", + "0.3 0 4.106174 \n", + "0.4 0 4.238759 \n", + "0.5 0 4.070399 \n", + "0.6 0 4.177144 \n", + "0.7 0 4.428134 \n", + "0.8 0 4.553163 \n", + "0.9 0 4.770353 \n", + "1.0 0 4.576663 \n", + "\n", + " Compression Time (Evictions) Compression Time (Put) \\\n", + "Time Steps \n", + "0.1 0.802742 0.010204 \n", + "0.2 1.401154 0.013810 \n", + "0.3 1.409992 0.012271 \n", + "0.4 1.465674 0.011588 \n", + "0.5 1.390100 0.011297 \n", + "0.6 1.511765 0.011077 \n", + "0.7 1.511029 0.013518 \n", + "0.8 1.534296 0.012791 \n", + "0.9 1.649169 0.012788 \n", + "1.0 1.595451 0.012677 \n", + "\n", + " Compression Time (Update) Decompression Time (No Cache) \\\n", + "Time Steps \n", + "0.1 0.005138 0 \n", + "0.2 0.005680 0 \n", + "0.3 0.005155 0 \n", + "0.4 0.004875 0 \n", + "0.5 0.004772 0 \n", + "0.6 0.004749 0 \n", + "0.7 0.005586 0 \n", + "0.8 0.005525 0 \n", + "0.9 0.005513 0 \n", + "1.0 0.005246 0 \n", + "\n", + " Decompression Time (Cache) Decompression Time (Evictions) \\\n", + "Time Steps \n", + "0.1 1.712582 0.344949 \n", + "0.2 3.138399 0.715304 \n", + "0.3 3.145418 0.752868 \n", + "0.4 3.161824 0.754601 \n", + "0.5 3.178370 0.781097 \n", + "0.6 3.105864 0.757371 \n", + "0.7 3.352016 0.819636 \n", + "0.8 3.441977 0.867595 \n", + "0.9 3.574588 0.900600 \n", + "1.0 3.428849 0.858553 \n", + "\n", + " Decompression Time (Put) Decompression Time (Get) \\\n", + "Time Steps \n", + "0.1 0.002933 0.006606 \n", + "0.2 0.005052 0.007748 \n", + "0.3 0.004465 0.007468 \n", + "0.4 0.004372 0.007395 \n", + "0.5 0.004280 0.007374 \n", + "0.6 0.004303 0.007318 \n", + "0.7 0.005080 0.008344 \n", + "0.8 0.004903 0.008236 \n", + "0.9 0.004944 0.008469 \n", + "1.0 0.004923 0.007983 \n", + "\n", + " Total Time (compression) Total Time (decompression) \\\n", + "Time Steps \n", + "0.1 2.774234 1.719188 \n", + "0.2 4.073944 3.146147 \n", + "0.3 4.111329 3.152886 \n", + "0.4 4.243634 3.169218 \n", + "0.5 4.075171 3.185745 \n", + "0.6 4.181893 3.113181 \n", + "0.7 4.433720 3.360361 \n", + "0.8 4.558687 3.450213 \n", + "0.9 4.775867 3.583056 \n", + "1.0 4.581910 3.436832 \n", + "\n", + " Cache Invalidates Number of iterations \\\n", + "Time Steps \n", + "0.1 914 8 \n", + "0.2 1612 10 \n", + "0.3 1612 10 \n", + "0.4 1612 10 \n", + "0.5 1612 10 \n", + "0.6 1612 10 \n", + "0.7 1783 11 \n", + "0.8 1783 11 \n", + "0.9 1783 11 \n", + "1.0 1783 11 \n", + "\n", + " Normalized Compression Calls Normalized Decompression Calls \\\n", + "Time Steps \n", + "0.1 188.250000 72.375 \n", + "0.2 201.700000 95.500 \n", + "0.3 201.700000 95.500 \n", + "0.4 201.700000 95.500 \n", + "0.5 201.700000 95.500 \n", + "0.6 201.700000 95.500 \n", + "0.7 201.636364 96.000 \n", + "0.8 201.636364 96.000 \n", + "0.9 201.636364 96.000 \n", + "1.0 201.636364 96.000 \n", + "\n", + " Compression Time (Cache compress) \\\n", + "Time Steps \n", + "0.1 1.956150 \n", + "0.2 2.653299 \n", + "0.3 2.683911 \n", + "0.4 2.761497 \n", + "0.5 2.669001 \n", + "0.6 2.654302 \n", + "0.7 2.903586 \n", + "0.8 3.006075 \n", + "0.9 3.108396 \n", + "1.0 2.968535 \n", + "\n", + " Decompression Time (Cache decompress) \n", + "Time Steps \n", + "0.1 1.364701 \n", + "0.2 2.418043 \n", + "0.3 2.388085 \n", + "0.4 2.402851 \n", + "0.5 2.392993 \n", + "0.6 2.344191 \n", + "0.7 2.527301 \n", + "0.8 2.569479 \n", + "0.9 2.669043 \n", + "1.0 2.565373 " + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "all_data_frames[5]" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "b5859b2d-0cf7-455b-ae72-08e213438a46", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cache_size = [1,2,4,8,16]\n", + "ax = all_data_frames[0].plot(y='Normalized Compression Calls',label='No Cache')\n", + "for i in range(1,len(all_data_frames)):\n", + " all_data_frames[i].plot(ax=ax,y='Normalized Compression Calls',label='Cache Size'+str(cache_size[i-1]))\n", + "plt.xlabel('Time step (s)')\n", + "plt.ylabel('Compression Calls')\n", + "plt.savefig('CompCalls_he.png')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "a42c8ca8-2b05-473e-8dcb-7a1514a1803b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cache_size = [1,2,4,8,16]\n", + "ax = all_data_frames[0].plot(y='Normalized Decompression Calls',label='No Cache')\n", + "for i in range(1,len(all_data_frames)):\n", + " all_data_frames[i].plot(ax=ax,y='Normalized Decompression Calls',label='Cache Size'+str(cache_size[i-1]))\n", + "plt.xlabel('Time step (s)')\n", + "plt.ylabel('Decompression Calls')\n", + "plt.savefig('DecompCalls_he.png')" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "696ba98d-8a54-4762-9c13-7fbe87a1506d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "all_df = []\n", + "df = pd.DataFrame({'Compression Time (No Cache compress)':all_data_frames[0]['Compression Time (No Cache)']})\n", + "df.plot(kind='bar', stacked=True, color=['red'])\n", + "plt.ylabel('Time (s)')\n", + "plt.title('Compression Time Overhead for No Cache')\n", + "plt.savefig('Comp_time_no_cache_he.png')\n", + "all_df.append(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "56a5005a-1580-4d92-90c5-1fb4a8bfc03d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# create stacked bar chart for monthly temperatures\n", + "for i in range(1,len(all_data_frames)):\n", + " df = pd.DataFrame({'Compression Time (Cache compress)':all_data_frames[i]['Compression Time (Cache compress)'],'Compression Time (Put)':all_data_frames[i]['Compression Time (Put)'],'Compression Time (Evictions)':all_data_frames[i]['Compression Time (Evictions)']})\n", + " df.plot(kind='bar', stacked=True, color=['red', 'skyblue', 'green'])\n", + " plt.ylabel('Time (s)')\n", + " plt.title('Compression Time Overhead Breakdown with Cache Size '+str(cache_size[i-1]))\n", + " plt.savefig('Comp_time_he_cache_size_'+str(cache_size[i-1])+'.png')\n", + " all_df.append(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "455867ee-d303-4e40-805c-bf91af9a2e50", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "all_df = []\n", + "df = pd.DataFrame({'Decompression Time (No Cache decompress)':all_data_frames[0]['Decompression Time (No Cache)']})\n", + "df.plot(kind='bar', stacked=True, color=['red'])\n", + "plt.ylabel('Time (s)')\n", + "plt.title('Decompression Time Overhead for No Cache')\n", + "plt.savefig('Decomp_time_no_cache_he.png')\n", + "all_df.append(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "c24c07de-cb6b-48b5-a833-1f373174dcf8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# create stacked bar chart for monthly temperatures\n", + "for i in range(1,len(all_data_frames)):\n", + " df = pd.DataFrame({'Decompression Time (Cache decompress)':all_data_frames[i]['Decompression Time (Cache decompress)'],'Decompression Time (Put)':all_data_frames[i]['Decompression Time (Put)'],'Decompression Time (Evictions)':all_data_frames[i]['Decompression Time (Evictions)']})\n", + " df.plot(kind='bar', stacked=True, color=['red', 'skyblue', 'green'])\n", + " plt.ylabel('Time (s)')\n", + " plt.title('Decompression Time Overhead Breakdown when not found in cache with Cache Size '+str(cache_size[i-1]))\n", + " # ax = plt.gca()\n", + " # ax.set_ylim([ymin, ymax])\n", + " plt.savefig('Decomp_time_he_cache_size_'+str(cache_size[i-1])+'.png')\n", + " all_df.append(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "b3df4dbe-bffe-41b1-8af1-72b030aaff58", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cache_size = [1,2,4,8,16]\n", + "ax = all_data_frames[1].plot(y='Cache Invalidates',label='Cache Size 1')\n", + "for i in range(2,len(all_data_frames)):\n", + " plt.savefig('CacheInvalidates_he.png')\n", + " all_data_frames[i].plot(ax=ax,y='Cache Invalidates',label='Cache Size '+str(cache_size[i-1]))\n", + " plt.xlabel('Time step (s)')\n", + " plt.ylabel('Cache invalidates')" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "20098f10-803f-4c6f-bb26-cdcaf4976ed4", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "eb9b78ea-ff8d-419b-9531-43f8f17ff805", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "bc708edd-7d0b-4cf0-bf74-b78aa97ccfe6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "7acc6bd6-8624-4298-8d42-f56477d3f934", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "6fb57d24-270c-41fa-9330-e85196e19e78", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAEtCAYAAADENy0eAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABelElEQVR4nO3dd3xT5f7A8c9J0nQPWkZbyvayhLJBRJQNIlBExhU3V7hOVK4K16sMFRT14rryQ3CBoiIoIKUiIg5wsEQKliFYZksLbdORjiQn5/dH2rShK4WmA77vlzVnPOecbx7afPOc8TyKpmkaQgghRDXS1XYAQgghLj+SXIQQQlQ7SS5CCCGqnSQXIYQQ1U6SixBCiGonyUUIIUS1k+QihBCi2rmdXMxmM2fPnsVsNnsyHiGEEJcBQ0Urjxw5wqpVq/j+++9JSkpC0zQURaFp06Zcf/31TJo0iXbt2tVUrEIIIeoJpbwn9GfMmMGff/7JTTfdRO/evWnTpg3+/v6YzWaOHTvGrl27iI2N5aqrruLVV1+t6biFEELUYeUml61btzJo0KBKd/Ddd98xcODAag9MCCFE/VVuchFCCCEullsX9GNjYzl27BgAf/31F7fddht33nmnc5kQQghRklvJ5bXXXiM4OBiAl156iejoaHr16sW8efM8GpwQQoj6qcK7xYqkp6fTsGFDCgoK2LNnD2+88QYGg4FrrrnG0/EJIYSoh9xKLqGhoZw4cYIjR47QuXNnjEYjeXl5yOUaIYQQZXEruTzwwAOMGzcOvV7vvO34l19+oX379h4NTgghRP3k9t1ieXl5APj6+gKQlpaG3W6nUaNGnotOCCFEvVRucrFYLBiNxkp34G45IYQQV45y7xYbM2YMy5YtIyUlpcz1qampLFu2jLFjx3oqNiGEEPVUuS2X9PR0li1bxtq1awkODqZVq1bO7l8SExPJzs7m5ptv5h//+AehoaE1HbcQQog6rNJrLhaLhfj4eA4fPkx2djZBQUG0a9eO6OhovLy8aipOIYQQ9Yh0/yKEEKLayWBhQgghqp0kFyGEENVOkosQQohq51Zy+eqrr8pcvmnTpmoNRgghxOXBrQv63bt357fffiu1vHfv3uzcudMjgQkhhKi/Kuxb7NSpUwBomuacLrlOnswXQghRlgpbLu3bt0dRlDJ7P27YsCEPP/wwkyZN8miAQggh6h+3TovdfvvtfPTRRzURjxBCiMtAlR6iTE5OJiUlha5du3owJCGEEPWdW3eLJScn8/e//50bb7yRe+65B3DcKfaf//zHo8EJIYSon9xKLs888wwDBgzgt99+w2Bw3APQr18/fv75Z48GJ4QQon5yK7ns37+fadOmodPpUBQFgMDAQLKzsz0anBBCiPrJreQSFhbGiRMnXJYdPXqUiIgIjwQlhBCifnMruUyZMoX77ruPzz//HJvNRmxsLI899hhTp071dHxCCCHqIbfvFtuyZQurVq0iKSmJ8PBwbr31VoYMGeLp+IQQQtRDV/x4Lna7HbPZjJeXl/N6khBCiIppmobVasXf3x+drvRJsAq7f8nOzubQoUP06tULgCVLlmCz2Zzr77jjDoKDg6s55JplNps5cuRIbYchhBD1Utu2bQkMDCy1vMLk8u6772IwGJzJ5e2333aeCjt9+jQ2m41HH320+qOtQUVDNbdt27Ze95V24MABOnXqVNth1BlSH8WkLlxJfbi62PqwWCwcOXKk3OHuK0wuW7Zs4Z133ikubDDw8ssvA3D27FmmTp1a75NL0akwo9GIt7d3LUdzaep7/NVN6qOY1IUrqQ9Xl1If5V1OqPBusdTUVMLDw53zEydOdE6Hh4eTkpJy0QEJIYS4fFV6K3J6erpz+oknnihzuRBCCFFShafFunfvzueff17m8yyff/65dGAphCjFbrdz+vRpzGZzbYdSJoPBwMGDB2s7jDqjsvrw9/cnKiqqzDvCKtxvRSsffPBB7rzzTlJTUxk2bBgNGzbk3LlzbN68mc8//5zly5dX6WBCiMvf+fPnURSFdu3aVfkDqSaYzWb8/f1rO4w6o6L6sNvtnDlzhvPnz9O4ceMq7bfC5NK5c2feffddXnnlFVauXIndbken0xEdHc0777xDdHR0lQ4mhLj8mUwmWrZsWScTi6ganU5HkyZNOHHiRPUmF3CcGvv444/Jy8sjKyuLoKAgfH19LzpYcfnSNE0eRBWoqlru7ami/vHy8nJ5vtFdlSaXIr6+vpJURLlOn8gg9rN4AkN8uOX27vj4yofLlUy+ZBTTNA1NA7tdQ7NrjtcSHaMoiuN/CoDiqLuS044yCkVVWtN1e7HHczu5CFEWm03lh6+P8PN3x/AP9OZ8ag7L3/qZW6f2JihYvoyI2me1Wlm8eDFxcXEYDAZsNhsDBw7kX//6l9stLE1zJAW7XeOt//0Pc66ZGY8+jr1weVHScE5fsLws69av4csNX6DoFKxWK32v6cf9/3yE8+fPMf+F2bz63/8rN55SycbxnyNJKaAULlAU+PjjD/lyw1pOnT7Jyy+9Rv/rri/cVkHRKej0VapOt0lyERct6ZSJ9Z/u49zZbLr1bsbQMR05c9LE6uW7ee/1n5g8tTeNI4JqO0xxhfv3v/9NQUEBa9aswc/Xn8ysTL6K+4qsTDO+Pr4XJALKTBAlWxq5Zgv5+VYy0nOdyxSl8INaUVB0oNMpGAw6dLqSyxV0hT9/JBxg7fpVfPLxKgKDglBtNo4ePUpoQ38ahPnx/vuOm6U0TQMNNBytn6JpNNA0nHFdOI2moeF4L126dKNfvxtY+NJz2KwqBfk2R2sKR0LyC/BMdqmx5JKYmMisWbMwmUyEhISwcOFCWrZs6VJGVVWef/55tm3bhqIoTJs2jQkTJgCwfft2Fi1axJEjR7jjjjuYOXOmc7u33nqLuLg49Ho9BoOBxx57jP79+9fUW7viqDY727b8ybZvjxIQYOTWe3vztw6Oi31t2jXi7gev5eN3dvL+/35m4j09aXVVw1qOWFwJNE1DVe2otqJXO4nHE/nmm2/4fPVGcjLtZJuyAIWBN4ykIA8O/rGf1954ifz8fCxWC6NHjeXvk25DURTy88y8/sYiDh76A51OR7eu3fn3v/+Dr58XqecymD3vcU6fPk3zZs15/Y3X8fX1xWKx8Oqrr7Jr1y6sVitt27Zl7ty5pe7GSks7T2BgICENghyj+3obiO7i6ILl9OnT3HLLLezYsYMffviBRYsWObc7duwYr732GkOGDGHt2rV8/PHHqKpKQEAAc+fOpXXr1qXqpVGTawAwehsICfWjSaTrFz5P3TLudnL566+/OHToELm5uS7Lx48f79b2c+bMYfLkycTExLB+/Xpmz57NihUrXMps2LCBkydPsnnzZkwmE2PHjqVv375ERUXRrFkznn/+eb7++mssFovLdtHR0UyZMgVfX18OHTrE7bffzvbt2/Hx8XH37Qk3nU3K4stPfudsUhbRPaMYHtMRXz/XPtnCmwYz5eF+fPzOTlYu3UHM37vSuXvTWopY1Katu0/yzc6T1bOzwm/nGoCmcX2Xplx7dYQzkaiqvdQmBw4kEBXVnLCwBuj1OvQGHVarFV9fb3Q6Hf5Bbflo5Qq8vb3Jzc1lwoQJjLxpKG3atOHf/55PSINAYmM3oNPpSE9Px8/fiMFLT8LBBNasWUNgYCD/+Mc/2LBhAxMnTuSdd94hMDCQNWvWAPDyyy+zdOlSHnvsMZe4+vXrx7Jlyxg4cCC9e/emd+/ejBkzptR17RtuuIEbbrgBgM8++4wvvviC/v37s3v3br766itWrlyJ0Wjkhx9+4KmnnuLTTz+tnrquBm4llyVLlvDWW2/Rvn17lw9sRVHcSi5paWkkJCTw/vvvAzBq1Ciee+450tPTCQ0NdZaLi4tjwoQJ6HQ6QkNDGTJkCJs2beLee++lRYsWAHz77belkkvJVkq7du3QNA2TyeTSdY24NKpq56etx/jxmyP4+hmZdE9P2nUqv35DQv2456FrWfX+btau3EuWKY9rB7aRC70epKp2bFYVq0XFai2ctqpknLOQfDoTLy89Bi9d4aseLy8dOn0dul1YK774XXzqp3C+8FRPSfl5ViwFNvQGHUZvA3qD4kwgBr0OvV5HSANfDAYdDcKKWw5msw1vH8e1FmuWheeee5bDhw+jKAqpqakcOnSINm3a8N133/HFF184b6ku+Vl13XXXERTkaAFER0dz8qQjgW7dupWcnBy+/vprwNG5Y/v27Uu9VT8/P1atWsX+/fvZs2cPq1evZuXKlc6kdKFt27bx3nvv8fHHH+Pt7c3WrVs5dOiQ88yOpmlkZWVdTK17jFvJZfny5axevbrMSnJHcnIyTZo0Qa93nNvT6/U0btyY5ORkl3+w5ORkIiMjnfMRERGcPXu2Ssdat24dzZs3r3JiOXDgQJXK10V79uzxyH6zTVb2/ZpJZrqVyBY+XN0zmJyCM+zZc6bSbTv2MmK1+fDtxkMcPXKSq3sEoehqJsF4qj7cpWkadhVUVcOuaoWna4p/7CXm7Squ622F21w47Zyn1H4qGpnp52+2lblc0YFer6DXK+j0SuEHtOMir95lXnHOO6ed87hs3zjcj6ysHBSgV7swercPQwHnNQDNDna16AK4Y5ldhbKGltIVXnB2XrvQgU5f+Orye6QVHQFVBVV1LG3VqhXHjx8nOTnZmQyg+FTQSy+9REhICB999BEGg4EHHniArKwszGYzmqaRm5tb6rSRxWJBp9M5l6uqSn5+PmazGVVVmTlzJr1793bZprxTT23atKFNmzbcfPPNDB48mPj4eOcwJkXbHDlyhNmzZ/PWW2/h7e2N2WzGYrEwZswY7r//freOc2GcF6rs1JjFYqny35NbycXHx6fMc3l1zc6dO3n99dd57733qrxtp06d6nVPqXv27KFHjx7Vuk+7XeOX74/x09dH8PYxMP7O7nTsEln5hhfo1VPjm9iD/PrDX/gYAxl3eze8jB66RaWQJ+rDXZpdY8f2RL7fdBhLgXpR+yhqYZRsZXh7l5x3LDN46fEyFpdxXe9oqfyVeIxWLds4WzJWq4rNandMW1RstgvmrcUtH5tVJT+/aN7m3LYiQ2/xISez8uciFMWRoAwGPXpvR4ujZMtDp1cuuaXboUMHBg8ezIsvvsj8+fMJCAggKyuLtWvXMn78ePLy8rj66qsJDg7myJEj7N27l5iYGPz9/Rk0aBCffPIJTz/9NIqiOM+0GI1GbDab8zpKyfkhQ4bw6aef0rdvX3x8fMjJySElJYU2bdq4xHXs2DFUVaVt27YAHD58GJvNRqtWrcjLywMc3a6kpKTw5JNP8vLLL9OxY0fn9sOHD2fmzJncfvvthIeHo6oqBw8erLDrfL1ej4+PT6nrP+70WGA0GunSpYvLsoKCggq/lLuVXB555BGef/55HnroIRo2dL04685TuBEREaSkpKCqKnq9HlVVSU1NJSIiolS5pKQk55P/F7ZkKrJ3716eeOIJFi9eXC8SYV13PjWH9Z/+zpkTJtp3DuemWzrjH3hxyVfRKQwb05HgBr58vf4PViz5hVun9MYvoP6On1OejDQz6z/dx8m/0mnTvhEtWoe5JIHSp6aKkkPxMoNBV62nD3MKztC+c/WdItY0DZut+LSbIyHZCxOPSlbuWRqE+TnvYCp6VcAlgeh0l5483PHiiy/y1ltvccsttzgfCBw4cCBGo5H777+fJ598ki+//JLmzZs7x64Cx11mCxYsYNSoUej1enr37s3TTz9d4bGmTZvG//73P8aPH194u7DCQw89VCq55Ofns2DBAtLS0vD29kav1/Pyyy8TFhbG6dOnneVWr15Neno6zz33nEtc11xzDY8++ij3338/qqpitVoZMWJEmcnlnXfeYcWKFaSnpzNr1iy8vb2Ji4sjICDgYqvULW4Nc1x0OqzkL0LR09judgB3xx13MH78eOcF/TVr1vDhhx+6lPniiy/YuHEjy5Ytc17QX7lyJc2aNXOWefPNN8nNzXW5Wyw+Pp7p06fz+uuvl8qulSnKvtJycbDbNXZuS2Rr3CEMXnpGjuvE1d0iq+1D4GB8MmtX7iUoxJfJU3sT2tAzfTzVdMtF0zT2/HKCbzYcRKdTGB5zNV16RdWJa0w1XRcHDx6kQ4cONXa8qpK+xVy5Ux9l/ZtW9tnpVsvl22+/rUKoZZs7dy6zZs1i8eLFBAUFsXDhQgCmTp3K9OnT6dy5MzExMezbt49hw4YBjo4zixLL7t27mTFjBjk5OWiaxsaNG5k/fz79+/dn3rx55OfnM3v2bOfxXnrpJdq1a3fJcV9J0s87vnWfSkznbx0bM2pCNIFB1XvHXYfoCPwDvVn13i7ee/Mnbv1Hb5o2D6nWY9S0zIw8vly1j8Q/z9O6bUNGT+xCcAN5gFRc2dxquRSx2+2cP3+ehg0bXjad0knLxXGNYNfPx/l24yF0OoURY68muqdnv3WfT83h42U7MOdYuOWO7rTt2KRa918T39Y1TeP3naf4en0CmqYxbExHul/TvE60VkqSlosrabm4qtWWS05ODs8++yxxcXHYbDYMBgM33XQTTz/9NIGBgVV4G6KuMaXn8uWqfRw/mkabdo0YPTGaoBDPf+tu2DiAKQ/345N3d7HqvV2MvKUzPfq28Phxq0t2Zj4bVsdz9GAqLdqEMmZSVxqE+dV2WELUGW4ll+eff568vDw2bNhA06ZNOXPmDK+++irPP/+88/SWqF80TeO3X0/yzYYEQGHUhGi69WlWo9+6A4J8uOuBvqxZsYeNa/aTacpj4Ih2de6bf0maprH/tzNsWvsHNpvK8LFX07tfyxq7vVqI+sKt5LJt2za2bNnifHq0VatWvPDCCwwdOtSjwQnPyMzIY8Nn8fx15BwtrwpjzKQuhITWzrduo7eBv0/pxcbP97N9y1GyTPmMnhCN3lD3TrvmZBewcU08hw+kENWiATG3diGskWfvuBGivnIruXh7e5Oenk7TpsVdeGRkZGA0Xn63kl7ONE1j367TfL3+D+x2jRvHdaJn3xa1/q1bp9cxakI0wQ18+X7TEbIz85l4dw/nU9R1QcK+JDau2Y/FojJkVAeuuaH1BQ/xCSFKciu5jB8/nilTpnD33XcTGRlJUlISH3zwARMnTvR0fKKaZGfmE7smnj8TUmneOpSYv3dx6RKjtimKwvVD2xIU7Evs6ng++F/d6LY/N8fCV2sP8MfvSUQ2Cybm711pFC7XGeuT6uhyv6SyHoe4GCtXruTTTz9FURQsFgsDBw5k5syZpKSk8Pjjj5d6VONi2O12HnnkEY4cOYK3tzdhYWHMmzeP5s2bX/K+K+NWcrn//vtp3LgxsbGxpKam0rhxY+699163O60UtUfTNA78doaviq4RxHSk93Wtar21Up6uvZsREOTNmhV7eO+Nn5g8tQ+Na+nD/PCBs8Su2U9eroUBI9px3aA2dasvLuGWoi73P//8cwICAjCZTM4OcGtrxMz4+HiWL1/OmjVrCAoKQlVV/vzzTwCaNGlSLYmlyNixYxk4cCA6nY6PPvqIZ555huXLl1fb/svjVnIp6qBSkkn9kpNdQNzn+zm0/2y9ukZwVfvG3PXAtXzyzk7ef/MnJt3Tk5Y12G1/Xq6Fr9f9QfyeMzSJDOK2aX0Ij5Rxaeqj48ePs2XLFn744QfnE+leXl5MmjQJcHS7Mm/ePPLy8igoKGDixIncfffdAGRnZ7NgwQIOHDiAoij07NnT+SxdSkoKU6dO5dSpUzRv3pzXX69al/spKSkEBATg5+e41qnX650Pq1dnl/s6nY7Bgwc757t27VojiQUqSC7r1q1j7NixAOX21Anud7l/OUo+ncnX6//A19eLwGAfAoN9CAr2ITDYt/DVB2+f2hmP7Y/fk4j7vP5eI4iICmbK9KJu+3cSc2sXOnXzfLf9Rw+lsmHVPnJyLPQf+jeuH/K3OnlzQX2RHf892fu2emTfgV0GERg9oMIyCQkJtGjRwtkZ5IWaNm3KBx98gNFoxGw2M2HCBPr370+bNm1YsGABfn5+rF+/3tnlfpEDBw7Uyy73V65cyaBBgyosU13K/eTbuHGjM7msX7++zDLudrl/uTJ66/H2NpCRlsuJv9LJz7OWUcbgTDRFryWng4J98A/wrrbTVLk5FuK+2E/CvuR6f42gZLf9X3y0lyxTPn0HtPbIrcoF+VY2f5nA3h2naNQkgElTehHZLKTajyPqlvz8fObOnXtFdLn/zjvvcOzYsdpvuSxbtsw5XZ3n/y4nYY0CuPXe4q61rRaV7Kx8skx5ZGfmk5WZT3ZWvnM68c/zZGcXoF0wprZOpxAQ5O1MNkHBvs4kVDIReXlV3JPwof1n2bgmnrw8KwNvbEe/gfX/GoGvn5Hbp/Vh3Se/syX2IFmmPIbFXF2trbC/jpxnw2f7nGPODBjeFkMldS3cExg9oNLWhSd17NiREydOkJmZWWbrZdGiRTRq1IgXX3wRg8HAlClTKCgoqHS/JZ9I1+v1zm00TWPOnDn07du30n0oikJ0dDTR0dHcdtttXHvttfz555+l4jx06BBz5szh3XffdSY4TdO45ZZbeOSRRyo9DsBHH31EbGwsH3zwQanWkae4dc4mPT0db29v/P39UVWVdevWodfrGTNmzGXTDUx18DLqCW3oX2FnjHa7hjmngOzMwqRjyierMAFlZ+Zz7mwOxw6fK7Ordl+/EqffggpfQ3wICPJh788ZJB1PJrxpELffdw1NLqOx6w1eem65vTtBIY5u+7My87n5tm6VJtvKWApsbIk9yO6fTxDa0J+7H+pHs5YNqilqURe0bNmSQYMGMXv2bGeX+6qqsnz5csaPH092djbt2rXDYDBw5MgRdu/ezahRowAYOHAg7777bqku9ysyaNAgPvjgA7p161alLvcTExOxWq2Eh4c7u9wHx7WZhx9+mJdeeolWrVq5HGfmzJlMmjSp0i73V61axapVq1i+fDkhISEXW5VV5lZy+ec//8m8efPo2LEjixYt4vvvv8dgMJCQkMBTTz3l6RgvKzqdQmCQj6NDyGbllyvItzpaPpnFLZ+SrylnssjJKXCMjwQoCtwwrC3XDbkKfT1vrZTF2W1/iA9ff5nAh//3K3+f0uuiu+0/8VcaX366j4z0XPpc34pBN7b3+BgzonZcyV3u5+TkMGfOHCIjI7nnnnsAx9gsq1evvuj6dJdbHVf26tWLnTt3Op5FuP56Pv30U/z8/Bg1ahTbt2/3eJCeVJ87rlRVOzlZBWRn5fNX4hGuH9CntkOqEQfjk/li5V5CGji67S/reZ3yOmu0WlW2xh1ix7ZEQhr4EfP3LrRoE1YTYdca6bjSlXRc6apWO67U6XRYrVYSExMJDAwkMjISu91e6dCYwrP0eh3BDXwJbuBLyvnauSutNnSIjuCOom773/iJW+/t7dbF99MnMlj/ye+knTPT89oWDBnVAaP3lVNvQtQkt/6yrr/+eh555BFMJhMjR44E4OjRozRpUr3dpAvhruatQrnnoX58/M4Oli/+hfF3dudvHcr+fbTZVH74+gg/f3eMwGAfbv9nH1q3bVTDEQtxZXErucyfP5+1a9diMBiIiYkBHH2LPfzwwx4NToiKNGxS3G3/p+/t5qZbOtH9Gtdu+5NOmVj/6T7Onc2ma+9mDBvTER/futNnmRCXK7eSi9FodD7RCo6LUd26dZOOK0WtK+q2f/WKPcSu3k9mRj4DRrTFrmp8v+kw2749in+Akb//o1e1D0gmhCifW7cVLVy4kPj4eAC+//57evfuTa9evdi61TNP3gpRFUXd9nfr3YxtW/7ki4/28tPm8/z4zZ906hbJ/U/cIIlFiBrmVstlw4YNTJ8+HYC33nqLl19+mcDAQF544YUa60pAiIro9TpGTYwmqIEvP3x9BKOPjol396B954jaDk2IK5JbySUvLw9fX18yMjI4deoUw4cPB+DMmTMeDU6IqlAUhRuGtaVNu0acOnNUEosQtcit02ItW7bkyy+/ZOXKlfTr1w9wPLXv4+Pj0eCEuBhRLRpg9L78HiQVF8dqtfL6668zfPhwbrrpJsaNG8eLL76I1Vq6L0B3vPnmm9UyvPvKlSsZPXo0Y8aMYcSIEc59pqSkcMcdd1zy/i+0du1a2rVrx3fffVft+y6LWy2XOXPmsGDBAgwGAwsWLABg+/btzkQjhBB11ZU+ngvA2bNnWbVqFV27dq3W/VbEreQSHR1dqivnMWPGMGbMGI8EJYQQ1eFKH8+lyDPPPMO///1vXnnlleqr3Eq4/XjyTz/9xMaNG0lPT2fJkiXs37+fnJwct3r/FEJcmX5I/JXvEn/2yL4HtrqWG1pdU2EZGc8FPv74Y6666iq6dOlSeaVWI7eSy4cffsiKFSuYMGGCc5wCHx8f5s+fL8lFCFFvXe7juZw6dYrVq1fzySefXEItXRy3ksvy5cv54IMPiIqKco7z0rp1axITEz0anBCifruh1TWVti486Uofz+X3338nNTXV2W3XuXPn+M9//sOMGTM8PtCjW7fUmM1mIiIct3UWjQJos9lq7WKYEEK4o+R4Ljk5OQDO8VzMZjPZ2dmEh4e7jOdSpGg8l6KO40ueFitP0Xgu+fn5gKPL+2PHjpUqd+zYMY4cOeKcLzmeS0kVjeeyfv16zp4963xPBw4cKHWc0aNH89NPP7F161a2bt1K165dmT9/fo2MIOxWy6VXr14sXbqU+++/37lsxYoV9OlzZXTxLoSov67k8Vxqk1vjuaSmpnLfffdhMplISUkhKiqKgIAAlixZQqNG7vUum5iYyKxZszCZTISEhLBw4UJatmzpUkZVVZ5//nm2bduGoihMmzbNeU5x+/btLFq0iCNHjnDHHXcwc+ZMt7arTH0ez6Wkmh6zo66T+igm47m4kvFcXNXaeC52u51jx47x8ccfc+TIEc6cOUNERATR0dFVGuJ4zpw5TJ48mZiYGNavX8/s2bNZsWKFS5kNGzZw8uRJNm/ejMlkYuzYsfTt25eoqCiaNWvG888/77w/3d3thBBC1LxKs4NOp+OBBx7Ax8eH6OhobrzxRrp27VqlxJKWlkZCQoJzbOpRo0aRkJBQ6hxmXFwcEyZMQKfTERoaypAhQ9i0aRMALVq0oGPHjhgMpfNhRdsJIYSoeW5liF69evH7779f9EGSk5Np0qQJer1jjHK9Xk/jxo1JTk4uVS4yMtI5HxER4bxgVdn+L2Y7IYQQnuHWBf3IyEimTp3K4MGDCQ8Pd94xBlR6K1x9UdadFvXNnj17ajuEOkXqo1hN1oXBYKjzQ6DX9fhqWmX1YbFYqvw75FZyKSgoYMiQIYDj1riqioiIICUlBVVV0ev1qKpKamqq8/bmkuWSkpKIjo4GSrdIKtr/xWxXklzQv7xIfRSrjQv6dfmCuVzQd+VOfRiNxlJP+Bdd0C+PW8nlhRdecKdYucLCwujQoQOxsbHExMQQGxtLhw4dXJ54BRgxYgSrV69m2LBhmEwmtmzZwsqVKyvd/8VuJ4QQwjPc7lvs+PHjfPXVV6SmptK4cWNuvPHGUrcSV2Tu3LnMmjWLxYsXExQU5OxeeurUqUyfPp3OnTsTExPDvn37GDZsGAAPPvggzZo1A2D37t3MmDGDnJwcNE1j48aNzJ8/n/79+1e4nRDiyma1Wlm8eDFxcXEYDAbncy7/+te/LupB8DfffJPc3FyXxyEuxsqVK/n0009RFAWLxcLAgQOZOXMmKSkpPP7449XWM/Lvv//O/PnzsVqtWK1Wbr/9dm699dZq2XdF3B6Jcvbs2dxwww1ERkZy5MgRli5dyrPPPsvo0aPdOlCbNm1YvXp1qeVF3cmA40L/vHnzyty+Z8+e/Pjjj2Wuq2g7IcSV7Urvcn/OnDk8+uijDBw4kNTUVIYPH87QoUNp2LBhtR2jLG4ll9dee42lS5e6PL26e/dunnzySbeTixBC1DTpct/RZVd2djYAubm5+Pv7l+p92RPcSi5ms7nUIDNdunQhNzfXEzEJIS4TqVu/J+XbrR7Zd5PBg2g8aECFZaTLfcc18wceeIBFixaRmZnJyy+/XCM3NLiVXO655x4WLVrEo48+ire3N/n5+bzxxhvcc889no5PCCE85nLvch/gnXfe4YknnmDkyJH89ddf3H333XTs2LHKd9RWlVvJ5eOPP+b8+fN8+OGHBAUFkZWVhaZpNGrUyGWcgO+//95TcQoh6qHGgwZU2rrwpCu9y/309HS2bNnCf//7X8AxVErbtm3Zt29f3UguL7/8skeDEEIITyjZ5f78+fMJCAhwdrk/fvx4srOzadeunUuX+0XdVBV1uf/000+jKArp6emlHp+4UFGX+926dcPHx4ecnBxSUlJK9Yp87NgxVFWlbdu2gGuX+3l5ec5yFXW5P3PmTCZNmkR4eDiqqnLw4MFSvSIHBwdjNBrZtWsXvXr14ty5cxw6dIirrrrqkurVHW4ll969e3s6DiGE8Igruct9vV7Pq6++yoIFC1BVFbvdzsMPP8zf/va3S6lSt7jV5b7NZiM2NpaDBw+Wuohf8k3XR9Ll/uVJ6qOYdLnvSp7Qd1VrXe4DPPHEExw5coTrr7+esLCwKoQthBDiSuRWctm2bRvff/+98z5xIYQQoiJudbl/1VVXkZmZ6elYhBBCXCbcvlvs6aefpl+/fqW6DBg7dqwn4hJCCFGPuZVcvvjiC3bv3k1mZiY+Pj7O5YqiSHIRQghRilvJZcWKFaxbt67U7XRCCCFEWdy65tKwYcNSA3sJIYQQ5XErudx11108/vjj/P7775w6dcrlRwgh6jKr1crrr7/O8OHDuemmmxg3bhwvvvgiVqv1ovb35ptvOsejuhQrV65k9OjRjBkzhhEjRjj3mZKSwh133HHJ+y/y7rvvMnz4cNq3b893333nss5ut7N48WKGDx/O6NGjmTZtWrUd163TYs8++yzg6JStJEVROHjwYLUFI4QQ1e1KH8+lV69eDBkypMzeBZYvX86JEyeIjY3Fy8uL8+fPV9tx3Uouhw4dqrYDCiFETZHxXBy9Npfnvffe45133nEm2eocQMztYY4BkpKSSElJITw8XK7BCCEqtW/3aX7fedIj++7auzldekZVWEbGcylfTk4OGRkZfPPNNzz99NPodDqmTp3KkCFD3N5HRdxKLqmpqcyYMYPff/+dkJAQTCYTXbp0YdGiRTRp0qRaAhFCiJp2JYznUh6r1YrVasVut7N69WpOnDjB5MmTadu2Lc2bN6/SvsriVnKZO3cu7du3Z+nSpfj5+ZGbm8uiRYuYM2cOS5YsueQghBCXpy49oyptXXjSlT6eS0UaNGiAn58fI0eOBKBFixZ07NiRhISEakkubt0ttmfPHmbOnOk8P+jn58eTTz7J3r17LzkAIYTwlJLjueTk5AA4x3Mxm81kZ2cTHh7uMp5LkaLxXIo6ji95Wqw8ReO55OfnA45TT8eOHStV7tixYxw5csQ5X3I8l5IqGs9l/fr1nD171vmeDhw44G61OI0aNYqff/4ZgLS0NA4dOlRt3fG71XIJDg7m2LFjLs27v/76y9ksFEKIuupKHs8FHMMcr1ixgvT0dGbNmoW3tzdxcXEEBATw2GOP8eSTT/LZZ5+hKAozZsyotofl3RrP5bPPPmPRokWMHz+eyMhIkpKS+OKLL3jkkUecd13UVzKey+VJ6qOYjOfiSsZzcVWr47lMnDiRZs2aERsby+HDh2ncuDH//e9/3TqvKIQQ4srj9q3Iffv2lWQihBDCLW5d0H/ooYdcLnQB7N69m+nTp3skKCGEEPWbW8ll165ddOvWzWVZ165d2bFjh0eCEkLUb25cyhX1xMX+W7qVXIxGI3l5eS7LcnNzMRiq9IC/EOIK4OPjQ1pamiSYy4CmaaSlpbmM4+Uut7LDddddx+zZs3n22WcJCAggJyeHZ599lv79+1f5gEKIy1tUVBSnT5/m3LlztR1KmSwWC0ajsbbDqDMqqw8fHx+ioqr+IKxbyWXWrFk88cQT9OrVi5CQEDIzM7n++ut56aWX3D5QYmIis2bNwmQyERISwsKFC2nZsqVLGVVVef7559m2bRuKojBt2jRn9wYVrUtLS+Pf//43ycnJWK1WrrnmGp5++mlpWQlRC7y8vFwe+Ktr9uzZQ5cuXWo7jDrDU/Xh9kOUS5cu5dy5cyQnJxMREUGjRo2qdKA5c+YwefJkYmJiWL9+PbNnz2bFihUuZTZs2MDJkyfZvHkzJpOJsWPH0rdvX6Kioipct2TJEtq0acPSpUuxWq1MnjyZzZs3O7s1EEIIUbPcuuYCkJGRwU8//cSOHTto1KgRKSkpzq4HKpOWlkZCQgKjRo0CHF0OJCQklOpOIS4ujgkTJqDT6QgNDWXIkCFs2rSp0nWKomA2m7Hb7VgsFqxWq3SoKYQQtcit5LJz505GjBjBhg0bWLx4MQAnTpxg7ty5bh0kOTmZJk2aoNfrAUdHb40bNyY5OblUucjISOd8RESEM4FVtO6BBx4gMTGR6667zvkjT2cLIUTtceu02IIFC3jttdfo27evs++dLl26EB8f79Hg3LVp0ybatWvn7Ixu6tSpbNq0iREjRri9j4vp9K2u2bNnT22HUKdIfRSTunAl9eHKE/XhVnI5c+aM8+l8RVEAx0U7VVXdOkhERAQpKSmoqoper0dVVVJTU0sNOBYREUFSUpJz5LSSrZWK1n300UcsWLAAnU5HYGAggwYNYseOHVVKLtK32OVF6qOY1IUrqQ9XF1sfRX2Llcet02Jt2rRh27ZtLst+/vln2rZt61YQYWFhdOjQgdjYWABiY2Pp0KGDy+A7ACNGjGD16tXY7XbS09PZsmULw4cPr3RdVFQUP/74I+C4re6XX36ptm6jhRBCVJ3btyL/85//ZMCAAeTn5zN79my2bt3qvP7ijrlz5zJr1iwWL15MUFAQCxcuBGDq1KlMnz6dzp07ExMTw759+xg2bBgADz74IM2aNQOocN1TTz3FnDlzGD16NKqq0qdPHyZOnOh+LQghhKhWbnW5D45Ba7788kuSkpKIiIhgzJgxpQa2qY+ky/3Lk9RHMakLV1Ifri71tNgldbkP0KRJE6ZOnVrlAIQQQlx5Kk0uR48e5c0332TPnj3Op+t79uzJQw89xFVXXVUTMQohhKhnKrygf/z4cSZOnEhBQQGPPfYY//d//8ejjz5KXl4eEydO5K+//qqpOIUQQtQjFbZc3n77bWJiYpgzZ47L8vHjx/Pcc8+xbNkyXnjhBY8GKIQQov6psOWya9cupkyZUua6e+65R8ZzEUIIUaYKk0t6enq5XS1HRkaSkZHhkaCEEELUb5U+RFn0RH6pDXW6ctcJIYS4slV4zSU/P5/bbrutzHWaplFQUOCRoIQQQtRvFSaX+fPnV7hx0WBdQgghREkVJpebb765puIQQghxGXF7sDAhhBDCXZJchBBCVDtJLkIIIaqdJBchhBDVrsrJpXv37p6IQwghxGWkysnFzeFfhBBCXMHktJgQQohqV+XkEhcX54k4hBBCXEaqnFwiIiI8EYcQQojLiJwWE0IIUe0kuQghhKh2klyEEEJUuwo7rizpp59+YuPGjaSnp7NkyRL2799PTk4Offv29WR8Qggh6iG3Wi4ffvghc+fOpWXLluzatQsAHx8fXn/9dY8GJ4QQon5yK7ksX76c999/n2nTpqHTOTZp3bo1iYmJHg1OCCFE/eRWcjGbzc5bkIuGNrbZbHh5eXkuMiGEEPWWW8mlV69eLF261GXZihUr6NOnj0eCEkIIUb+5dUH/6aef5r777mP16tWYzWaGDx9OQEAAS5Ys8XR8Qggh6iG3kkvjxo35/PPPiY+PJykpiYiICKKjo53XX4QQQoiS3L4VWVEUunTpQpcuXS7qQImJicyaNQuTyURISAgLFy6kZcuWLmVUVeX5559n27ZtKIrCtGnTmDBhQqXrwNHn2f/93/+haRqKovD+++/TsGHDi4pVCCHEpXEruRw6dIgFCxZw6NAhcnNzAZwf4gcOHHDrQHPmzGHy5MnExMSwfv16Zs+ezYoVK1zKbNiwgZMnT7J582ZMJhNjx46lb9++REVFVbhu//79/O9//2P58uU0atSI7OxsjEZjFatCCCFEdXHrvNaMGTPo3r07H330EXFxccTFxfHVV1+53UNyWloaCQkJjBo1CoBRo0aRkJBAenq6S7m4uDgmTJiATqcjNDSUIUOGsGnTpkrXffDBB0yZMoVGjRoBEBgYiLe3t3s1IIQQotq51XI5f/48jzzyiPM25KpKTk6mSZMm6PV6APR6PY0bNyY5OZnQ0FCXcpGRkc75iIgIzp49W+m6Y8eOERUVxW233UZubi5Dhw7l/vvvv+h4hRBCXBq3ksvYsWPZsGEDY8aM8XQ8F0VVVQ4fPsz777+PxWLh3nvvJTIykrFjx7q9D3dP79Vle/bsqe0Q6hSpj2JSF66kPlx5oj7cSi7Tpk1j0qRJvP3224SFhbmsu/C6SVkiIiJISUlBVVX0ej2qqpKamlpqbJiIiAiSkpKIjo4GXFsrFa2LjIxkxIgRGI1GjEYjgwcPJj4+vkrJpVOnTvX6VNqePXvo0aNHbYdRZ9R2fVizssn64w/Q6TH4+6H388Pg7++Y9vVFKWzF14Tarou6RurD1cXWR0FBQYVfyt1KLtOnTycqKoqhQ4de1AdwWFgYHTp0IDY2lpiYGGJjY+nQoYPLKTGAESNGsHr1aoYNG4bJZGLLli2sXLmy0nWjRo3ihx9+ICYmBpvNxq+//srw4cOrHKcQl6IgLZ30HTtJ++VXMg/8AXZ7uWX1vr6FCac48ej9/TD4+aH39y98LVzuV/pV7+sjp31FneZWcjl48CA7duy4pDuw5s6dy6xZs1i8eDFBQUEsXLgQgKlTpzJ9+nQ6d+5MTEwM+/btY9iwYQA8+OCDNGvWDKDCdTfddBMHDhxg5MiR6HQ6rrvuOsaPH3/RsYqqs5nNmPb+DjodwZ074RUYWNsh1Yj8s2dJ+2UHab/sIPvwYQB8m0YSNW4sDXr2QDEYUHNzUXNzsZnN2MxF07moZjO2wnUWkwn1TJJj3mxGU9WKD6zTORLQhQmqaL5EglKTkzlfYEHR6Rw/ej0UTV84r9ej6HQl5nXF84Xrypp37sODCU/TNCj8udhpza6hZedgzcpGMehR9Hp0BoPHY69LNE1DU9XKf8cukaJpmlZZoalTpzJjxgw6dOjg0WBqQ1HTTk6LVZ01M5O0HbtI//VXTPv2o9lsjhWKgn/r1oR06UxIl2gCO7RHX8N166n60DSN3JOnSPvlV9J/3YE58TgA/q1bEdb3GsL6XoNfs6hLPobdYkE152LLNTtezWZHUsrNxZZjLjNhuczn5VXYcvIYRSkjYRUmJEUHmh1NAzQ7aKAVvRbFWviqXfBaE+9FMRgcCdOgR9EbChNP4bTB4FyuK0xKZZcvWba88obC06Iamk11ftBrNlvxtKpit6loqg1NtTteS86XW7ZoX2Vtq5ZOKjodxjsm02vczVWur8o+O91quURFRTFlyhSGDh1a6prLI488UuWgRP1VcO48ab/uIO3XHWQlHAS7HZ/wJkSMGknYNY6+5kz74smM30/Sl7Gc+WIdipcXQR3aExztSDYBbVrX6DWHS6VpGjl/HiXtl19J+3UH+UnJoCgEtm9Hyyl3EXZNH3yaNKm24ymKgt7bG723N8bQBhcXs92Omp+Pas4lfs9uOrZvj2a3o6l2sNsd03b1gvmi9apzWrOrF6y/cL7E9qpjuzLnVdX5bByKDhRQCl9RdCgKUNjjh3LBq8tyRSnch3LR0ydOHKdZZFOXD3R7yQ/rounCD2i7rWhZ8Ye03WbDbrWi5eUXf6g791V2+UoTpE7nSE56ffGPM3HpCpNc8bqisjqjEUMlZV2SXIkEp/fx4UyD4Iv6HauMW8klPz+fAQMGYLVanbf/iitH7ukzpBcmlJw/jwLg16I5zSbc4vim3rKFyymFoA7t4e8TUfPyyEo4iCl+P5n74jn50cec/Ohj9P5+BHfqREiXzgR3ica3adM6d0pCU1WyEg46Tnn9ugNLWhqKXk9w505EjhlNWJ/eF/3BXxOUwtNmBj8/dI0a4X9BbxhXsjN79hBZCxf0nQm3MHGhlGgt6fW19jeQ5KE759xKLi+88IJHDi7qJk3TMCcmFl5L+JW8U6cBCPjb32hx5+2EXdMH36aRlezFcdG6QY/uNOjRHXCcRjPFHyAzPh7T7/Gk79gJgDEslODoaEeyiY7GOyy0ot16jN1qxbQvnrRfdpC+cxe2rCx0RiMh3boQdvtkGvTqccVcSxLVz3m96goZqqTc5HL69Gmiohznjk+dOlXuDoouqov6TbPbyT58xHHq55cdFKSmOi7OX92RiBuHE9qnD94NwyrfUQW8goNp1L8fjfr3AxwXw03x+zH9Hk/G7j2c++57AHyjopytmuBOV2Pw97/Ut1cuNT+fjN/2kvbLr2Ts2oOal+dIir16EHbNNTTo3hW9r6/Hji/E5arc5DJ69Gj27t0LwNChQ1EUhQuv/SuKwsGDBz0bofAYu81G5v4DjlNeO3ZizTChGAyEdO1Cs0njCe3VE69gz5yPBfAJDyc8PJzwYUPR7HbMx0+QuS8eU/x+UrZsJXnjV6DTEXBVG0K6RBMc3ZmgDu3RXeI3P1tODum7dpP2yw5Me3/HbrFgCAwkrN+1hPXtQ0iX6Es+hhBXunKTy969e5133Bw6dKgmYxIepBYUYNr7u+PUz67dqGYzOh8fGvTo5vim3rM7Bj+/Go9L0ekIaN2KgNataHpzDHarlezDRxw3B+zbz+nP13J69efojEaCOnYguEs0IV2i8W/VsvjCbwUsGRmk79jleAZl/wE0VcUYFkqToUMI69uHoI4d6tVNBkLUdRVec5k6dSq//fZbTcVS72Qf+ZNj//c2ej8/jA1CMDZogFeDBqWmDQEBbn0AeorNbCZj92+OUz+/7cVeUIAhIICwPr0IveYaQrpG1/itwpXReXkR3OlqgjtdDbfdii03l6wDfzjvRDux/ENOAIbAAII7d3bcidY1Gp/wcOeF0fyUVNJ+3UH6rzvIOngINA2fiHAiY0YT1vcaAq5qU6v/LkJczipMLm48AnNF8woKxLdpJJa0dHKOHsOSYcKen1+qnGIw4BUcjLFBiDPheIWEYAxtgDGkAcbQBo75BiHoqmmoAIspk/SdO0n/dYfzGRSvBg1oPGig45v61R0dD4/VEwY/P0J79yK0dy8ALOkZmOIdrRrTvnjSfv4FAO9GDQm6uiMFh4+wJ9lxZ6N/q5Y0+/tEx51tzZvVuTvThLgcVfrpUtHFfLiyL+j7hIfT7vEZLsvUvDwsGRlYMkxYTSYs6RnOV4vJhOX8eXL+PIo1M9Px9PAF9P7+JVo+ha+Fiae4NdQAQ2BAqQ/JgnPnHM+g/FL4Tb3kMyh9ryGw7d8um2/qxtAGNB5wA40H3ICmaeQnJRe2auIdPQUEBNLirjsI63sNvhHhtR2uEFecCpNLXl4ew4YNK7cFIxf0S9P7+uLr64tvZMW36mqqijUzC4spwyUBWU0mLBkmLBkZ5Bw5iiUjA3tBQantFYPBmXS8QkIoOHOG3UnJQMXPoFyOFEXBt2kkvk0jiRg5AnA8oR8lnRMKUWsqTC6+vr7OO8ZE9VL0esdpsdAG0Lr8cpqmoeblY83IwGLKwFqYeCwZJseyDBMF586BTuf4pn5N70oTmxBCeFqFyeVy/8ZbHyiKgsHPF4Ofb4UPLso3dSFEXVLhCXi5oC+EEOJiVJhc4uLiaioOIYQQl5EKk8uFI0UKIYQQ7rg87ksVQghRp0hyEUIIUe0kuQghhKh25d6KfMMNN7h1K/L3339fnfEIIYS4DJSbXF5++WXn9P79+1m3bh133HEHkZGRJCUl8dFHHzF27NiaiFEIIUQ9U25y6d27t3P62Wef5d1336VJiXHCr7/+eu69916mTJni2QiFEELUO25dc0lNTcXvgjE+/Pz8SElJ8UhQQggh6je3+lwfNGgQ999/P/fffz/h4eEkJyfz9ttvM2jQIE/HJ4QQoh5yK7nMmzePN998kzlz5pCamkqjRo248cYbeeihhzwdnxBCiHrIreTi7e3N448/zuOPP+7peIQQQlwG3B6K0GKxkJiYSEZGhkuHln379vVIYEIIIeovt5LL7t27efTRR7FYLOTk5BAQEIDZbCY8PJxvv/3W0zEKIYSoZ9y6W+yFF17g3nvvZefOnfj7+7Nz507uv/9+Jk+e7On4hBBC1ENuJZfjx49z5513uiybNm0aH3zwgSdiEkIIUc+5lVwCAwPJyckBoFGjRhw9epSsrCxyc3PdPlBiYiKTJk1i+PDhTJo0iePHj5cqo6oq8+bNY8iQIQwdOpTVq1e7ta7IX3/9RZcuXVi4cKHbcQkhhKh+biWXoUOH8sMPPwAwfvx47rzzTsaNG8eIESPcPtCcOXOYPHkyX3/9NZMnT2b27NmlymzYsIGTJ0+yefNmVq1axZtvvsnp06crXQeO5DNnzhyGDBnidkxCCCE8w60L+v/5z3+c01OmTCE6Ohqz2Uz//v3dOkhaWhoJCQm8//77AIwaNYrnnnuO9PR0QkNDneXi4uKYMGECOp2O0NBQhgwZwqZNm7j33nsrXAewdOlSBgwYQG5ubpVaVEIIIaqf27ciAyQnJ5OSkkLPnj2rdJDk5GSaNGmCXq8HQK/X07hxY5KTk12SS3JyMpGRkc75iIgIzp49W+m6Q4cOsX37dlasWMHixYurFFuRAwcOXNR2dcmePXtqO4Q6ReqjmNSFK6kPV56oD7eSS1JSEjNmzODQoUMoisLevXvZtGkT27ZtY/78+dUeVFVYrVaeeeYZXnjhBWfyuhidOnXC29u7GiOrWXv27KFHjx61HUadIfVRTOrCldSHq4utj4KCggq/lLt1zWX27NkMGDCA3377DYPBkY/69evHzz//7FYQERERpKSkoKoq4Lg+kpqaSkRERKlySUlJzvnk5GTCw8MrXHfu3DlOnjzJtGnTGDRoEMuXL+ezzz7jmWeecSs2IYQQ1c+t5LJ//36mTZuGTqdzDiAWGBhIdna2WwcJCwujQ4cOxMbGAhAbG0uHDh1cTokBjBgxgtWrV2O320lPT2fLli0MHz68wnWRkZHs2LGDrVu3snXrVu666y4mTpzIc88953YlCCGEqF5unRYLCwvjxIkTtGrVyrns6NGjpVoeFZk7dy6zZs1i8eLFBAUFOW8Xnjp1KtOnT6dz587ExMSwb98+hg0bBsCDDz5Is2bNACpcJ4QQom5xK7lMmTKF++67j2nTpmGz2YiNjeXtt99m6tSpbh+oTZs2ZT6bsmzZMue0Xq9n3rx5ZW5f0bqSHn74YbdjEkII4RluJZfx48cTEhLCqlWriIiIYO3atTzyyCPyTIkQQogyuX0r8pAhQySZCCGEcIvbyWX79u0cPHiw1AOKjzzySLUHJYQQon5zK7k8++yzfPXVV/Tp0wdfX19PxySEEKKecyu5bNy4kXXr1lXp7jAhhBBXLreecwkJCSEwMNDTsQghhLhMlNtyOXXqlHP6nnvu4fHHH+ef//wnDRs2dCknz5oIIYS4ULnJZejQoSiKgqZpzmXff/+9SxlFUTh48KDHghNCCFE/lZtcDh06BICmaZw6dYrIyEhnv2JCCCFERSq95qIoCmPGjEGnc+vyjBBCCOHeBf0OHTqQmJjo6ViEEEJcJtw6z9W7d2+mTp3KzTffTHh4uLNnZHB0DSOEEEKU5FZy+e2332jatCk7d+50Wa4oiiQXIYQQpbiVXD788ENPxyGEEOIy4vZV+oyMDNatW8c777wDQEpKinMMeyGEEKIkt5LLzp07GTFiBBs2bOCtt94C4MSJE8ydO9eTsQkhhKin3EouCxYs4LXXXuPdd991PuvSpUsX4uPjPRqcEEKI+smt5HLmzBn69u0L4LxTzMvLC1VVPReZEEKIesut5NKmTRu2bdvmsuznn3+mbdu2HglKCCFE/ebW3WKzZs3in//8JwMGDCA/P5/Zs2ezdetWFi9e7On4hBBC1ENuJZeuXbvy5Zdf8uWXX3LLLbcQERHBmjVrCA8P93R8QogyaJqG1W7Dolqw2KwUqBYsqoUCW+GranXOH8v8i9zjKt4GIz4Gb3wM3ngbjHgXTvvojRgNRnSKdPEkqo9byeXgwYN06NCBqVOnejoeUY8U2Cyk55kcP7mOV52iI9QvmAY+IYT6BtPANwRvg7G2Q61xVtVKZkE2BbbiD3yL6kgCjvniD/+CwnUW53Rhcigx75JACtdpaJUHUujrc9srLeOtN5ZKOt5lJSODEW990XLHfNG0t750AvPSGVx69SiLpmlomoZds5f4cZ1XK1hXNK/a1XLXFf0czUmk4KSGar9wv45ti/ahamrxsS8s61Km8PWCMuWVtdtVVM2OAiiKDkVR0Ck6dIqCglI471hWNK8oOnQULlMKy5QxrxTtR1HQUbzvon0W799Rzqg30kj1zFhdbiWXe+65h9DQUEaNGsXo0aNlDJcSMvOz8NJ74WvwqfQPqL6wa3ayC3JIz8t0SRxpeRlklJg3W/Pc2p+/ly+hviE08A2hgW9w4bTjtWg6xCcIvU7v4Xd2aWyqjcyCbEz5WWTmZ2Eq8ZOZ77o81826KeKl98Ko93J8wBe2JIrm/Y1+ruv0XhgNxdPeBiPGEtOO5cXzCQcSaHd1e/KtBRSoBRTYLOTbCsi3FU8XqAXk2ywUlFheoBaQby0g22J2WZ6vFrgMxVEZnaLD22DES2eo8IO/Rl3EI3p6Ref4UNbp0SkKeqXkqw6dTucsU1y2aL6wrE6PoUQrsSihamjYNQ1NU4uTLFpx0qWwnHPeXlje7lzv3Fe58/ZS+/bSGZgUcWM1V66DW8nlp59+Ytu2bcTGxhITE8Pf/vY3Ro0axciRIwkLC/NIYPXBztO/88pPbwOOPyB/L1/8jX74e/k5Xo1+xcuMfgQY/fDzcry6rPPyq7Fepy2q1ZEgnC2OzOLEUZg00vMzUe2udwIqikKITxChviGEBzamY+O2zuQQ6hfinLZrdjKKklKeyTmdkZdJRp6JM1lnycjPLPVhoqAQ7BNYIvkU7TPYZVmg0b9ak7hqV8ksyC5MDpnOJFGcNIqTR47FXOY+/Lx8CfYJJMQnmOYhTYn26UCITxBB3oH4enmX+LA3FiYCL5cEYtR7efSU1GmvACIDm1Tb/opOyTmSzQXJSrWQb8svTlrO1wKsdlvhN2ad85uzvvCD2nW5rpxl5a0rntfrKt/PoYMH6Xx15wuSQWEcOteEoS+RIC5Hmqbx22+/eWTfbiUXvV7PgAEDnBf0v/32Wz755BMWLlzIgQMHPBJYfdA1vCMP9L6TrIIczJZczNZcx6slF7M1j/O56ZgtueRYc0t9WF/I18vHmZQcSciReAJcElXRdPE6v8JvtZqmFbY2TBe0NkwurY3sMj4gvfVGZ5Jo3+iqMpNGVVoW/kY/ooIjyl1vt9vJKsgmPS+TjPxM0nNNZOSbHPN5Js7nZnAkLZHsgpxS2xp0Bkey8QmmgV+I47VECyjUN5gQ32DMtlyOZ5wmsyALU16W89VUkE1mfiamwiSSU2Au8/SSj8GbEJ8ggn2CiAqK4OrGbQnxCSbEJ9C5PMQniGDvQIxX2Gk/RVGcSRHvgNoOp8rSvVMr/P28knjybEuVRv8qKCjgu+++Iy4ujgMHDtCzZ09PxVUvGA1GBrTqW2k5TdOwqFZHorGYybXmkeNMQsUJKceaS64lD7M1l7M558i15JFjzaXAVlDh/r30Xmh2O7ZjpRNYsHcgob4hhPmH0rZh6zITh5+Xb42e0tPpdIQUJoGKWFUrpvwslxZQUQJKzzNx0nSGfXkJ5Nnyy97BcddZo96LEJ8gQnyCCQ9oRPuGbZxJougn2CeQYJ8gfAze1fNmhbhCuZVcfvjhBzZs2MDWrVu56qqrGDlyJHPnzqVRo0aeju+yoChK4cVNI6F+IVXe3qbaHEnImleiZVSYkCy55FrzSD57lo4t27kkjQY+wRj09Xf0UC+9F438w2jkX/Gp1zxrfmHCcSQgU34mKWdS6Nz26hJJw5EwLpfrYkLUdW598ixcuJCbbrqJdevW0bx5c0/HJC5g0BsI1js+IMuzx7aHHu161GBUdYevlw++XuFEBhXfGr/HvIcezbrXYlRCXNncSi5xcXGXfKDExERmzZqFyWQiJCSEhQsX0rJlS5cyqqry/PPPs23bNhRFYdq0aUyYMKHSdW+99RZxcXHo9XoMBgOPPfYY/fv3v+SYhRBCXJxKk8vp06f53//+x08//URGRgYNGjSgb9++PPTQQ1VqxcyZM4fJkycTExPD+vXrmT17NitWrHAps2HDBk6ePMnmzZsxmUyMHTuWvn37EhUVVeG66OhopkyZgq+vL4cOHeL2229n+/bt+Pj4VL1GhBBCXLIKk8uxY8e49dZb6dKlC4899hiNGjXi3LlzfPXVV4wfP55PPvmENm3aVHqQtLQ0EhISeP/99wEYNWoUzz33HOnp6YSGhjrLxcXFMWHCBHQ6HaGhoQwZMoRNmzZx7733VriuZCulXbt2aJqGyWSSHgSqkaZpaNYC1Lws7Lk5jte8bNTcbNS8bOy5Wah52SgGb7xCGmEIboQhuDGGkEYYAsNQ6vgzLNVJ0+yo5izUnHQ0mxXNroJdRVNtjmlVRbMXTdvQ7HYonNdU1TFdWAa7WmJ5iX2UmlbL3UdQXh6nf/NH0XuB3oBS9KMzoBhKLNMVvhq8UPQG0JUoa/BC0Rlct9d7Oae5YL54ecllekABpfCn8IG++sRu17DYVAosKharnQKrzfFqUbFYVQqKfixqiXIXLC+c1jQKH2zUCm+ZBkWnoQf0CiiKVvhaOE2JZSWmdQqF+3B0FqlTNBRFc+5XKVymU7Ti6cL342U0Ygzw8khdVZhcXnnlFSZPnsyjjz7qsnzcuHG8+uqrvPzyyyxZsqTSgyQnJ9OkSRP0escHjF6vp3HjxiQnJ7skl+TkZCIjI53zERERzgHJKlpXUtF1IUks5dM0Dc2SX5goHMlBzc2iICcTS3YWlpxMbLmO5KHlZ6MUmNFZzOg0W7n7zNO8MWveGBUbQUqu6/EUHZpvA/TBjfAJbYJPaLgj6dTD5KNpdtScTGzZaeRnnCP73Fly01KxZp7Hbs5An2fCaM1CT/X0GG5Hh6bosCt6NEXvqEtFD4oOTedYhq54nqJ5nReKzhf0esy6XAIUH7CpYLGh2PPBbkOx21DsKmiqc1qx21A0R3LSaTXT67njI09BU6DwY9OxXCmeRlGc5YqncSYpl/LlLnPs38tq44/v9aAVP6SI8xXHrelF84XTjp1pzmgde9JcXvVo+AMBCqXKuUwrxdvoqtDLgqccbXMzXNOr2vdbYXLZvXs3CxcuLHPdlClTGDx4cLUHdCl27tzJ66+/znvvvVflbS/meR3Nbsd05jSaai/8XVZK/A4XThc+fKWU+J9S9Aqg0zl+90tu69y+5De7EtvpHHegaUX7UBQ01cq22HWo+Wbs+XlQkItiyUNnzUVvy8Og5uOl5mG05+Oj5aOn7Cei7RrkFiYKs73wVWuI2R6FWfMmHx8sem+sel9Ugy92L180L1+MRj3eBh1WVSM3twDysvAqyCLAnkWozkxofg6hmWmEnjlBkJKHrsR7taNQYAjAagzG7heM4h+CPjAEzTcEu28wdp8gRz1V0Z49e6q2gWZHKTCj5GVizc7CmpOJlpuFkp+FlyUHH2s2vpoZ/QUfCIqmI9fuh8nuT5YWQq4+CotXIKrRH1UxoGo6bOhQ7Qo2dNjsOmwo2LTCZZpj2qbpsGoKNrsOa+FyuwZ2O4Xdhjj+fYqmPU9Djx09dgxK0auKATt6xY6e4mkDqrOMY96xrGhar6josV/wIetMK0DxB23xh3HhN+wLyhWnmeJyzmWlyhaVK1m28P8Kzr8xRSlsReiK5xWdgk5X3B2LoitqXRQ+nFn4d6jTFXbXolOc2zgeEC3axrHM+c6L/qYvSJ5F86WS5AXly15f3CIszJFohZ8RjnmlxHyJmjB4Eda4RdX/VtxQYXJRVdU5OFipDQ0Gt8dziYiIICUlBVVV0ev1qKpKamoqERERpcolJSURHR0NuLZWKloHsHfvXp544gkWL15M69at3YqrpE6dOuHtXbVnG3Z/FUvrPz6q8rFqiqopzkSRo3mTrwRi0TfGpvfDZvRH8woA3wB03gHo/YMw+AXiExiEn48RP18vwr0N+Pt64Vvi1aCv2od8gVUlPTOf85l5pGXmk2jKI92UQ156KvbMcyi5aXgXZBCqyyE0L4fQnEQCldxSycfiFYTNNxRdUCOMIY3xbxRBcHgk3qFNHC2fC2653rNnDz16FN89p9lV1BwT5rQUMlPPYj6fQoHpPGp2OkpuOl6WTHzVnFLfJC2anky7Hxl2P3L14Vi9QxytsMBQvBs0xD8snAYNwwgP8eXqYF/8fCrvR6u62O0aqr2wj6yiadUxr9o157L4/QfodPXVhZ89hR+cJb7M6BTF+QWnKIeXWU5X/GVGp1xQrvD0S8nponIV1Yej5VA47VhQPO2c1ZzTWontigqWWgYV7jN+3z769O5R5d/ly9WFfyvuKigoqPBLeYXJpXPnznzxxRfcfvvtpdatXbuWTp06uRVEWFgYHTp0cHYfExsbS4cOHVxOiQGMGDGC1atXM2zYMEwmE1u2bGHlypWVrouPj+exxx7jjTfe4Oqrr3YrpurQdegIDgWGoFot2Aub1mgaGiWb2IBmL2xRl1xX9AdTskmulfhj0Fy2ce67sNmuOJvtjn1kZGbRKKol3gFBGAND8A0KxjcoiIa+Rvx8vDAadLVyftvbS09EQ38iGvqXW0a1a5iy80nLzCctM49D6TnknE/BkpGCPfs8+tx0fHJNhORmE5qRgs+pXAoUSC3c3o5Cnj6QAmMImn8Y+sCGZKadY+ev69HlmfC2ZuJrN7skDm9A0fRk2P3Jxp98QySqbzD4h2IIaohvg4YENGxCaKOGXBXiS0iAN/o69mGkK/yW7FXJsExng71o1sQznRNeqqLkVGKJx4/pY9RJYqkBFSaXRx55hH/84x8kJiYyfPhw5wX9TZs2sXbtWt599123DzR37lxmzZrF4sWLCQoKcp5umzp1KtOnT6dz587ExMSwb98+hg0bBsCDDz7o7CSzonXz5s1zjjNT5KWXXqJdu3ZVqIqqMxgMdLruOo8ew10X++2jLtDrFMKCfQkL9gUaFC51HYhO0zRy8qykZeZzPj2bzNQU8s8nYzGdg5xzeOVn4Gc2EZxzmKBzv+OL3nGaShdAgVcz7P4hKAFhGIMb4hfWmMCGTQhtFEqLED98vevvg6ZC1FWKVkn3pnv37uWVV15h79692O12dDodXbt25V//+le9/TArqahpdzGnxeqS+pxcqlO+xUa6KY8jhxO4vl/vEue6r1zyu+FK6sPVpZ4WK++zs9KvbN26dWPlypXk5+eTmZlJUFAQvr6+VQ5EiJrgYzQQ2TiQ5FMGSSxC1CK3zwf4+PjIQ4lCCCHcIle1hBBCVDtJLkIIIaqdJBchhBDVzu1rLj/99BMbN24kPT2dJUuWsH//fnJycujbt/LBsoQQQlxZ3Gq5fPjhh8ydO5eWLVuya9cuwHGB//XXX/docEIIIeont1ouy5cv54MPPiAqKoply5YB0Lp1axITEz0aXE0oeszHYrHUciSXrqCg4uGQrzRSH8WkLlxJfbi6mPoo+sws71FJt5KL2Wx29gNW1IWIzWbDy8szXTXXJKvVCsCRI0dqOZJLdzGdb17OpD6KSV24kvpwdSn1YbVay3xMxa3k0qtXL5YuXcr999/vXLZixQr69Olz0QHVFf7+/rRt2xYvL696N7aEEELUFk3TsFqt+PuX3W9gpd2/AKSmpnLfffdhMplISUkhKiqKgIAAlixZQqNGjao9aCGEEPWbW8kFHFkqPj6epKQkIiIiiI6ORncRY2wIIYS4/LmdXIrYLxilSBKMEEKIC7l1zeWPP/7g2Wef5fDhw867CjRNQ1EUDh486NEAhRBC1D9utVxGjx7NwIEDiYmJKXVXQNOmTT0WnBBCiPrJreTSvXt39uzZI3dTCSGEcItbF0yGDh3K9u3bPR2LEEKIy0S5LZcnnnjC2VKxWCx899139OjRg4YNG7qUe+mllzwfpRBCiHql3JZLixYtaN68Oc2bN+eqq65i6tSpdO/e3bms6EdUr8TERCZNmsTw4cOZNGkSx48fL1VGVVXmzZvHkCFDGDp0KKtXr3Zr3VtvvcVNN93EmDFjGDduHNu2bauJt3RJPFkfRf766y+6dOnCwoULPflWLpmn6yIuLo7Ro0czatQoRo8ezfnz5z39li6JJ+sjLS2NadOmMXr0aEaMGMHcuXOx2Ww18bYu2qXWx/bt2xk3bhydOnUq9bfgzt9RKZqoU+644w5t3bp1mqZp2rp167Q77rijVJm1a9dqU6ZM0VRV1dLS0rT+/ftrp06dqnTdjz/+qOXm5mqapmkHDx7UevTooeXl5dXQO7s4nqwPTdM0m82m3X777dqMGTO0F198sWbe1EXyZF3Ex8drN954o5aamqppmqZlZWVp+fn5NfTOLo4n6+P55593/j5YLBZt/Pjx2saNG2vonV2cS62P48ePa3/88Ye2aNGiUn8Llf0dlcWtay5Lly4lPj7eZVl8fLyzE0tRPdLS0khISGDUqFEAjBo1ioSEBNLT013KxcXFMWHCBHQ6HaGhoQwZMoRNmzZVuq5///74+voC0K5dOzRNw2Qy1dwbrCJP1wc4frcHDBhAy5Yta+x9XQxP18UHH3zAlClTnD1uBAYG4u3tXYPvsGo8XR+KomA2m7Hb7VgsFqxWK02aNKnZN1kF1VEfLVq0oGPHjhgMpZ9QqezvqCxuJZcVK1Zw1VVXuSxr06YNy5cvd2dz4abk5GSaNGmCXq8HQK/X07hxY5KTk0uVi4yMdM5HRERw9uzZSteVtG7dOpo3b054eLgn3kq18HR9HDp0iO3bt3P33Xd7+J1cOk/XxbFjxzh16hS33XYbN998M4sXLy63t9u6wNP18cADD5CYmMh1113n/OnRo4en39ZFq476qGz/Vd3OreRitVpLZTMvL6/Lopv6K9HOnTt5/fXX+e9//1vbodQaq9XKM888w7x585x/kFcyVVU5fPgw77//Ph9++CE//vgj69evr+2was2mTZto164d27dv58cff2T37t2VflMXrtxKLldffTUff/yxy7JPP/2Ujh07eiSoK1VERAQpKSmoqgo4/uBTU1Odwx2ULJeUlOScT05OdrZAKloHsHfvXp544gneeustWrdu7cm3c8k8WR/nzp3j5MmTTJs2jUGDBrF8+XI+++wznnnmmRp4Z1Xn6d+NyMhIRowYgdFoJCAggMGDB5c6FV6XeLo+PvroI8aMGYNOpyMwMJBBgwaxY8cOT7+ti1Yd9VHZ/qu6nVvJ5d///jfvvPMO48aN45FHHuHmm29m2bJlPP300+5sLtwUFhZGhw4diI2NBSA2NpYOHToQGhrqUm7EiBGsXr0au91Oeno6W7ZsYfjw4ZWui4+P57HHHuONN97g6quvrtk3dxE8WR+RkZHs2LGDrVu3snXrVu666y4mTpzIc889V+Pv0x2e/t0YNWoU27dvd3aj/uuvv9K+ffuafZNV4On6iIqK4scffwQcj2L88ssv/O1vf6vBd1g11VEfFbmo7dy9EyEnJ0eLjY3Vli1bpsXGxmo5OTnubiqq4OjRo9r48eO1YcOGaePHj9eOHTumaZqm3XvvvVp8fLymaY47nGbPnq0NHjxYGzx4sPbpp586t69o3bhx47Q+ffpoY8aMcf4cOnSoZt9gFXmyPkp644036vzdYp6sC1VVtQULFmgjRozQRo4cqS1YsEBTVbVm32AVebI+Tpw4od19993aqFGjtBtvvFGbO3euZrVaa/YNVtGl1seuXbu0/v37a926ddO6du2q9e/fX/vxxx8r3a48Ve4VWQghhKiMW70i22w2Pv74Y3bt2kVGRobLXSQrV670WHBCCCHqJ7euubzwwgusWrWKnj178scffzBs2DDS0tK45pprPB2fEEKIesit5LJ582aWLVvGXXfdhV6v56677uKtt96q03dPCCGEqD1uJZf8/HznLW0+Pj7k5eXRpk0bEhISPBqcEEKI+smtay5t2rRh//79REdH06lTJ958800CAgLqdHcIQgghao9bLZennnrK+RTzrFmzSEhI4LvvvquzzwQIUZ1uuummy/4U8NGjRxk3blyl5VasWMErr7xSAxGJ+k5uRRZXvG7dujmn8/LyMBqNzi9T8+bNY8yYMbUVGgCnT59m8ODB/PHHH2V2KlgdHn74YUaMGMFNN91UYbmCggKGDh3K2rVrCQsL80gs4vJQYctlz549vPzyy2Wue+WVV/j99989EZMQNWrv3r3On8jISJYsWeKcr+3EUhNSU1PZsWMHQ4YMqbSst7c3119/PevWrfN8YKJeqzC5vP322/Tq1avMdb169WLJkiUeCUqIumTQoEH8/PPPALz55ptMnz6dxx9/nG7dujF69GgSExN5++236du3LzfccIPLkODZ2dk89dRTXHfddfTv359XX33V2f/TheLj4xk3bhzdu3fn2muv5YUXXgDg9ttvBxx/c926dWPv3r0ArFmzhhtvvJFevXrxj3/8gzNnzjj31a5dO1asWMHgwYPp06cPCxcuxG63l3ncn3/+mY4dO7p0sb906VL69+9Pt27dGD58OL/88otzXe/evfn+++8voibFlaTC5HLw4EH69+9f5rp+/fpx4MABjwQlRF323XffERMTw65du+jQoQP/+Mc/sNvt/Pjjjzz44IPMnj3bWXbmzJkYDAY2b97MunXr+Omnn8odxW/+/Pnceeed/Pbbb3zzzTfceOONgKMTRYBdu3axd+9eunXrxpYtW3j77bf53//+xy+//EKPHj3417/+5bK/b775hs8//5y1a9eydetWPv/88zKPe/jwYVq1auWc/+uvv1i5ciVr1qxh7969vPvuuzRt2tS5vk2bNhw+fPjiKk9cMSpMLjk5OVit1jLX2Ww2zGazR4ISoi7r2bMn/fv3x2AwMGLECDIyMpg2bRpeXl6MHDmSM2fOkJWVxfnz5/nxxx956qmn8PPzIywsjLvvvpuNGzeWuV+DwcDJkydJT0/H39+frl27lhvDp59+yrRp02jTpg0Gg4H77ruPgwcPurRepk6dSkhICJGRkdx5553OTg0vlJ2djb+/v3Ner9djsVg4duwYVquVqKgolyHN/f39yc7OrmKtiStNhcmldevWLk38krZv317nu2wXwhNKXsj28fGhQYMGzhsAfHx8AMjNzSUpKQmbzcZ1111Hz5496dmzJ7Nnzy41OmCR+fPnc/z4cW688UZuueUWvvvuu3JjSEpKYsGCBc799u7dG03TSElJcZYp2d1606ZNSU1NLXNfQUFBLl8UW7RowVNPPcWbb77Jtddey2OPPeayX7PZTGBgYEVVJETFz7ncfffdzJkzB7vdzpAhQ9DpdNjtdrZs2cKzzz7LrFmzaipOIeqd8PBwjEYjv/76q1t3ebVs2ZJFixZht9vZvHkz06dPZ8eOHSiKUqpsREQE9913X4U3HCQnJzu7iU9KSqJx48ZllmvXrl2pC/SjR49m9OjR5OTkMHv2bF555RXnzT3Hjh2jXbt2lb4fcWWrsOUyevRo7r33XmbOnEl0dDTXXXcd0dHRzJo1i3vvvdc5XrMQorTGjRvTr18/XnzxRXJycrDb7Zw8eZKdO3eWWX79+vWkp6ej0+kICgoCHKeoQkND0el0nDp1yln273//O0uXLuXPP/8EHKe2vvrqK5f9vfvuu2RmZpKcnMyKFSsYOXJkmcft168fCQkJFBQUAI5rLr/88gsWiwWj0Yi3t7fLaJ27du3i+uuvv/iKEVeESr9O3XPPPUyYMIG9e/diMpkICQmhW7duBAQE1ER8QtRrL730Eq+88gojR47EbDbTrFkzpk6dWmbZbdu28eKLL5Kfn09kZCSvvvqq8w6u++67j1tvvRWbzcY777zD0KFDMZvNzJgxgzNnzhAYGMi1117rvAkAYPDgwYwbN46cnBxuvvlmxo8fX+ZxGzZsSJ8+ffj2228ZOXIkFouF//73vxw7dgwvLy+6devGs88+Cziec/nhhx/44osvqrmmxOVGHqIU4jLUrl07Nm/eTIsWLdwqf/ToUWbOnMmaNWvKPA1X5MMPPyQ5OZknn3yyukIVlylJLkJchqqaXISobm71LSaEEEJUhbRchBBCVDtpuQghhKh2klyEEEJUO0kuQgghqp0kFyGEENVOkosQQohqJ8lFCCFEtft/O27cNcO2OkgAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "73d965bd-7d4f-4aac-a54f-ce7e3ce7af60", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pySDC/projects/compression/allencahn_example.py b/pySDC/projects/compression/allencahn_example.py index d28991ddae..04bbe67154 100644 --- a/pySDC/projects/compression/allencahn_example.py +++ b/pySDC/projects/compression/allencahn_example.py @@ -11,6 +11,13 @@ allencahn_imex_timeforcing, ) from pySDC.projects.compression.log_datatype_creations import LogDatatypeCreations +from pySDC.projects.compression.log_compression_ratio import LogCompressionRatio, LogCacheSize +from pySDC.projects.compression.log_num_registered_var import LogRegisteredVar, LogActiveRegisteredVar +from pySDC.projects.compression.log_time_metrics import LogTimeCompression, LogTimeDecompression +from pySDC.projects.compression.log_num_comp_decomp_calls import LogCompDecompCalls, LogCompCalls, LogDecompCalls +from pySDC.projects.compression.log_clear_stats import LogClearStats +from pySDC.projects.compression.log_cache_invalidates import LogCacheInvalidates +from pySDC.projects.compression.log_cache_history import LogCacheHistory from pySDC.projects.compression.compression_convergence_controller import ( Compression_Conv_Controller, ) @@ -31,7 +38,8 @@ def run_AC(Tend=1): problem_params["comm"] = MPI.COMM_SELF convergence_controllers = {} - convergence_controllers[Compression_Conv_Controller] = {"errBound": 1e-9} + # convergence_controllers[Compression_Conv_Controller] = {"errBound": 1e-9} + convergence_controllers[Compression_Conv_Controller] = {"errBound": 1e-9, "losslesscompressor": "zstd"} # initialize level parameters level_params = {} @@ -57,13 +65,24 @@ def run_AC(Tend=1): controller_params["logger_level"] = 15 controller_params["hook_class"] = [ LogSolution, + LogRegisteredVar, + LogActiveRegisteredVar, + LogCompressionRatio, + LogCacheSize, + LogTimeCompression, + LogTimeDecompression, + LogCompCalls, + LogDecompCalls, + LogCacheInvalidates, + LogCacheHistory, + LogClearStats # LogDatatypeCreations, ] # fill description dictionary for easy step instantiation description = {} - # description['problem_class'] = AllenCahn_MPIFFT_Compressed - description["problem_class"] = allencahn_imex_timeforcing + description['problem_class'] = AllenCahn_MPIFFT_Compressed + # description["problem_class"] = allencahn_imex_timeforcing description["problem_params"] = problem_params description["sweeper_class"] = imex_1st_order description["sweeper_params"] = sweeper_params @@ -72,9 +91,7 @@ def run_AC(Tend=1): description["convergence_controllers"] = convergence_controllers # instantiate controller - controller = controller_nonMPI( - controller_params=controller_params, description=description, num_procs=1 - ) + controller = controller_nonMPI(controller_params=controller_params, description=description, num_procs=1) # get initial values on finest level P = controller.MS[0].levels[0].prob @@ -88,19 +105,153 @@ def run_AC(Tend=1): def main(): from pySDC.helpers.stats_helper import get_list_of_types, sort_stats, filter_stats + import pandas as pd - stats = run_AC(Tend=0.002) - print(get_list_of_types(stats)) + stats = run_AC(Tend=0.01) + # print(get_list_of_types(stats)) # print("filter_stats", filter_stats(stats, type="u")) # print("sort_stats", sort_stats(filter_stats(stats, type="u"), sortby="time")) - u = get_sorted(stats, type="u") - # print(u) - import matplotlib.pyplot as plt - - # plt.plot([me[0] for me in u], [me[1] for me in u]) - # plt.show() - plt.imshow(u[-1][1]) - plt.savefig("result_AC") + # u = get_sorted(stats, type="u") + u = get_sorted(stats, type="compression_ratio") + v = get_sorted(stats, type="num_registered_var") + w = get_sorted(stats, type="num_active_registered_var") + cs = get_sorted(stats, type="num_arrays_cache") + y = get_sorted(stats, type="num_comp_calls") + z = get_sorted(stats, type="num_decomp_calls") + time_comp_nocache = get_sorted(stats, type="execution_time_comp_nocache") # No cache + time_decomp_nocache = get_sorted(stats, type="execution_time_decomp_nocache") + time_comp = get_sorted( + stats, type="execution_time_comp" + ) # Time - not found in cache - compress, eviction maybe, add to cache (put) + time_decomp = get_sorted(stats, type="execution_time_decomp") + time_comp_update = get_sorted(stats, type="execution_time_comp_update") # Found in cache - update or get it + time_decomp_get = get_sorted(stats, type="decomp_time_get") + time_comp_eviction = get_sorted(stats, type="comp_time_eviction") # Eviction time for write back cache + time_decomp_eviction = get_sorted(stats, type="decomp_time_eviction") + time_comp_put = get_sorted(stats, type="comp_time_put") # Only put operation + time_decomp_put = get_sorted(stats, type="decomp_time_put") + t_comp = get_sorted(stats, type="total_time_comp") # Total time + t_decomp = get_sorted(stats, type="total_time_decomp") + cache_inv = get_sorted(stats, type="cache_invalidates") + # cache_hist = get_sorted(stats, type="cache_history") + iters = get_sorted(stats, type="niter") + # cache_hits = get_sorted(stats, type="cache_hits") + # cache_misses = get_sorted(stats, type="cache_misses") + print("Compression Ratio:") + print(u) + print("\nNumber of registered variables:") + print(v) + print("\nNumber of active registered variables:") + print(w) + print("\nNumber of compression calls:") + print(y) + print("\nNumber of decompression calls:") + print(z) + print("\nNumber of cache invalidates:") + print(cache_inv) + print("Wrapper compression time nocache:\n") + print(time_comp_nocache) + print("Wrapper decompression time nocache:\n") + print(time_decomp_nocache) + print("Wrapper compression time:\n") + print(time_comp) + print("Wrapper decompression time:\n") + print(time_decomp) + print("Wrapper compression time update:\n") + print(time_comp_update) + print("Wrapper decompression time get:\n") + print(time_decomp_get) + print("Wrapper compression time eviction:\n") + print(time_comp_eviction) + print("Wrapper decompression time eviction:\n") + print(time_decomp_eviction) + print("Wrapper compression time put:\n") + print(time_comp_put) + print("Wrapper decompression time put:\n") + print(time_decomp_put) + + x, comp_calls = zip(*y) + x, decomp_calls = zip(*z) + x, time_comp_nocache = zip(*time_comp_nocache) + x, time_comp = zip(*time_comp) + x, time_comp_update = zip(*time_comp_update) + x, time_comp_eviction = zip(*time_comp_eviction) + x, time_comp_put = zip(*time_comp_put) + + x, time_decomp_nocache = zip(*time_decomp_nocache) + x, time_decomp = zip(*time_decomp) + x, time_decomp_get = zip(*time_decomp_get) + x, time_decomp_eviction = zip(*time_decomp_eviction) + x, time_decomp_put = zip(*time_decomp_put) + x, cache_inv = zip(*cache_inv) + x, iters = zip(*iters) + x, t_comp = zip(*t_comp) + x, t_decomp = zip(*t_decomp) + df = { + 'Time Steps': x, + 'Compression Calls': comp_calls, + 'Decompression Calls': decomp_calls, + 'Compression Time (No Cache)': time_comp_nocache, + 'Compression Time (Cache)': time_comp, + 'Compression Time (Evictions)': time_comp_eviction, + 'Compression Time (Put)': time_comp_put, + 'Compression Time (Update)': time_comp_update, + 'Decompression Time (No Cache)': time_decomp_nocache, + 'Decompression Time (Cache)': time_decomp, + 'Decompression Time (Evictions)': time_decomp_eviction, + 'Decompression Time (Put)': time_decomp_put, + 'Decompression Time (Get)': time_decomp_get, + 'Total Time (compression)': t_comp, + 'Total Time (decompression)': t_decomp, + 'Cache Invalidates': cache_inv, + 'Number of iterations': iters, + } + data_frame = pd.DataFrame(df) + data_frame.to_csv("result_cache_size_" + str(cs[0][1]) + "_nolog_blosc.csv", index=False) + + # with open("result_cache_size_"+str(cs[0][1])+"_nolog_blosc.txt",'w') as fp: + + # Number of Compression calls + # fp.write(' '.join('{} {}'.format(x[0],x[1]) for x in y)) + # fp.write('\n')#Number of Decompression calls + # fp.write(' '.join('{} {}'.format(x[0],x[1]) for x in z)) + # fp.write('\n')#Execution time for compression no cache + # fp.write(' '.join('{} {}'.format(x[0],x[1]) for x in time_comp_nocache)) + # fp.write('\n')#Execution time for compression + # fp.write(' '.join('{} {}'.format(x[0],x[1]) for x in time_comp)) + # fp.write('\n')#Execution time for compression update + # fp.write(' '.join('{} {}'.format(x[0],x[1]) for x in time_comp_update)) + # fp.write('\n')#Execution time for compression eviction + # fp.write(' '.join('{} {}'.format(x[0],x[1]) for x in time_comp_eviction)) + # fp.write('\n')#Execution time for compression update + # fp.write(' '.join('{} {}'.format(x[0],x[1]) for x in time_comp_put)) + # fp.write('\n')#Execution time for decompression no cache + # fp.write(' '.join('{} {}'.format(x[0],x[1]) for x in time_decomp_nocache)) + # fp.write('\n')#Execution time for decompression + # fp.write(' '.join('{} {}'.format(x[0],x[1]) for x in time_decomp)) + # fp.write('\n')#Execution time for decompression update + # fp.write(' '.join('{} {}'.format(x[0],x[1]) for x in time_decomp_get)) + # fp.write('\n')#Execution time for compression update + # fp.write(' '.join('{} {}'.format(x[0],x[1]) for x in time_decomp_eviction)) + # fp.write('\n')#Execution time for compression update + # fp.write(' '.join('{} {}'.format(x[0],x[1]) for x in time_decomp_put)) + # fp.write('\n')#Number of cache invalidates + # fp.write(' '.join('{} {}'.format(x[0],x[1]) for x in cache_inv)) + # # fp.write('\n')#Cache History + # # fp.write(' '.join('{} {}'.format(x[0],x[1]) for x in cache_hist)) + # fp.write('\n')#Number of iterations + # fp.write(' '.join('{} {}'.format(x[0],x[1]) for x in iters)) + # fp.write('\n')#Total time for compression + # fp.write(' '.join('{} {}'.format(x[0],x[1]) for x in t_comp)) + # fp.write('\n')#Total time for decompression + # fp.write(' '.join('{} {}'.format(x[0],x[1]) for x in t_decomp)) + # fp.close() + # import matplotlib.pyplot as plt + + # # plt.plot([me[0] for me in u], [me[1] for me in u]) + # # plt.show() + # plt.imshow(u[-1][1]) + # plt.savefig("result_AC") if __name__ == "__main__": diff --git a/pySDC/projects/compression/cache_manager.py b/pySDC/projects/compression/cache_manager.py new file mode 100644 index 0000000000..e11efc3431 --- /dev/null +++ b/pySDC/projects/compression/cache_manager.py @@ -0,0 +1,102 @@ +import numpy as np + +np.bool = np.bool_ +import os + + +class Cache: + def __init__(self): + self.cache = {} + self.cacheFrequency = {} + self.countCache = {} + self.cacheSize = 0 + self.cacheInvalidates = 0 + self.cache_hits = 0 + self.cache_misses = 0 + self.total_accesses = 0 + + # Return array block existing in cache, function is called only if varName key exists so array will be returned + def get(self, varName): + # get initial count (frequency) of array to update countCache dictionary and remove it + prev_count = self.cacheFrequency[varName] + + # Increment frequency counter for access to this array + self.cacheFrequency[varName] += 1 + count = self.cacheFrequency[varName] + + # In countCache dictionary, delete the value varName in key count and add varName to key count's list + self.countCache[prev_count].remove(varName) + if not self.countCache[prev_count]: + self.countCache.pop(prev_count, None) + + if count not in self.countCache.keys(): + self.countCache[count] = [] + self.countCache[count].append(varName) + else: + self.countCache[count].append(varName) + return self.cache[varName] + + # Add array to the cache if it doesn't exist or update the existing block of array + def put(self, varName, data): + # if varName in self.cache.keys(): + # self.cache[varName] = data + # prev_count = self.cacheFrequency[varName] + # self.cacheFrequency[varName] += 1 + # count = self.cacheFrequency[varName] + # self.countCache[prev_count].remove(varName) + # if not self.countCache[prev_count]: + # self.countCache.pop(prev_count,None) + # if count not in self.countCache.keys(): + # self.countCache[count] = [] + # self.countCache[count].append(varName) + # else: + # self.countCache[count].append(varName) + + # else: + # Implement LFU cache eviction policy + if len(self.cache) + 1 > self.cacheSize: + # get minimum count and then the first in the list is evicted and the new array is added there + try: + # print('Here:') + # print(self.cache) + # print(self.countCache) + minKey = min(self.countCache.keys()) + # print(minKey) + + evictArray = self.countCache[minKey][0] + # print(evictArray) + self.countCache[minKey].remove(evictArray) + if not self.countCache[minKey]: + self.countCache.pop(minKey, None) + self.cache.pop(evictArray, None) + self.cacheFrequency.pop(evictArray, None) + self.cacheInvalidates += 1 + # print(self.cache) + # print(self.countCache) + # print('Array Eviction done') + + # Add the new array + self.cache[varName] = data + self.cacheFrequency[varName] = 1 + count = self.cacheFrequency[varName] + if count not in self.countCache.keys(): + self.countCache[count] = [] + self.countCache[count].append(varName) + else: + self.countCache[count].append(varName) + + # print(self.cache) + # print(self.countCache) + # print('New Array Added') + except: + print('Failed to evict correctly') + os._exit(1) + else: + self.cache[varName] = data + self.cacheFrequency[varName] = 1 + count = self.cacheFrequency[varName] + if count not in self.countCache.keys(): + self.countCache[count] = [] + self.countCache[count].append(varName) + else: + self.countCache[count].append(varName) diff --git a/pySDC/projects/compression/compressed_mesh.py b/pySDC/projects/compression/compressed_mesh.py index f9769a5aa1..9b13aaa924 100644 --- a/pySDC/projects/compression/compressed_mesh.py +++ b/pySDC/projects/compression/compressed_mesh.py @@ -12,9 +12,10 @@ class compressed_mesh(object): Attributes: values (np.ndarray): contains the ndarray of the values + manager: contains the CRAM Manager variables """ - manager = CRAM_Manager("ABS", "sz3", 1e-5) + manager = CRAM_Manager("ABS", "blosc", 1e-5, "zstd") def __init__(self, init=None, val=0.0): """ @@ -31,9 +32,7 @@ def __init__(self, init=None, val=0.0): self.manager.name += 1 # if init is another mesh, do a copy (init by copy) if isinstance(init, compressed_mesh): - values = self.manager.decompress( - init.name, 0 - ) # TODO: Modify manager to copy compressed buffer + values = self.manager.decompress(init.name, 0) # TODO: Modify manager to copy compressed buffer self.manager.registerVar( self.name, values.shape, @@ -62,12 +61,11 @@ def __init__(self, init=None, val=0.0): ) # something is wrong, if none of the ones above hit else: - raise DataError( - "something went wrong during %s initialization" % type(self) - ) + raise DataError("something went wrong during %s initialization" % type(self)) def __del__(self): # print('Delete'+' ' +self.name) + # exit() self.manager.remove(self.name, 0) def __add__(self, other): @@ -207,6 +205,14 @@ def flatten(self): return self.manager.decompress(self.name, 0).flatten() +if __name__ == "__main__": + arr1 = compressed_mesh(init=((30,), None, np.float64), val=1) + arr2 = compressed_mesh(init=((30,), None, np.float64), val=2.0) + + c = arr1 + arr2 + + print(c.manager.mem_map) + print(type(c)) ''' def apply_mat(self, A): """ @@ -302,9 +308,7 @@ def __init__(self, init, val=0.0): self.expl = compressed_mesh(init, val=val) # something is wrong, if none of the ones above hit else: - raise DataError( - "something went wrong during %s initialization" % type(self) - ) + raise DataError("something went wrong during %s initialization" % type(self)) # def __sub__(self, other): # """ diff --git a/pySDC/projects/compression/compression_convergence_controller.py b/pySDC/projects/compression/compression_convergence_controller.py index b84d27f377..3501347834 100644 --- a/pySDC/projects/compression/compression_convergence_controller.py +++ b/pySDC/projects/compression/compression_convergence_controller.py @@ -8,15 +8,18 @@ class Compression(ConvergenceController): def setup(self, controller, params, description, **kwargs): default_compressor_args = { # configure which compressor to use - "compressor_id": "sz3", + "compressor_id": "blosc", # configure the set of metrics to be gathered "early_config": { "pressio:metric": "composite", "composite:plugins": ["time", "size", "error_stat"], }, # configure SZ + # "compressor_config": { + # "pressio:abs": 1e-10, + # }, "compressor_config": { - "pressio:abs": 1e-10, + "blosc:compressor": "zstd", }, } @@ -30,9 +33,7 @@ def setup(self, controller, params, description, **kwargs): "min_buffer_length": 12, } - self.compressor = libpressio.PressioCompressor.from_config( - defaults["compressor_args"] - ) + self.compressor = libpressio.PressioCompressor.from_config(defaults["compressor_args"]) return defaults @@ -65,6 +66,7 @@ def setup(self, controller, params, description, **kwargs): defaults = { "control_order": 0, "errBound": 1, + "losslesscompressor": "zstd", **super().setup(controller, params, description, **kwargs), } @@ -73,6 +75,7 @@ def setup(self, controller, params, description, **kwargs): # self.manager = x.manager self.manager = compressed_mesh(init=((30,), None, np.float64)).manager self.manager.errBound = defaults["errBound"] + self.manager.losslesscompressor = defaults["losslesscompressor"] return defaults def dependencies(self, controller, description, **kwargs): diff --git a/pySDC/projects/compression/heat_example.py b/pySDC/projects/compression/heat_example.py index 9e1ffa06db..1665771d30 100644 --- a/pySDC/projects/compression/heat_example.py +++ b/pySDC/projects/compression/heat_example.py @@ -8,6 +8,13 @@ from pySDC.implementations.hooks.log_solution import LogSolution from pySDC.projects.compression.compressed_problems import heat_ND_compressed from pySDC.projects.compression.log_datatype_creations import LogDatatypeCreations +from pySDC.projects.compression.log_compression_ratio import LogCompressionRatio, LogCacheSize +from pySDC.projects.compression.log_num_registered_var import LogRegisteredVar, LogActiveRegisteredVar +from pySDC.projects.compression.log_time_metrics import LogTimeCompression, LogTimeDecompression +from pySDC.projects.compression.log_num_comp_decomp_calls import LogCompDecompCalls, LogCompCalls, LogDecompCalls +from pySDC.projects.compression.log_clear_stats import LogClearStats +from pySDC.projects.compression.log_cache_invalidates import LogCacheInvalidates +from pySDC.projects.compression.log_cache_history import LogCacheHistory from pySDC.projects.compression.compression_convergence_controller import ( Compression_Conv_Controller, ) @@ -59,13 +66,23 @@ def run_heat(residual_tolerance=1e-4, errBound=1e-8, resolution=64, Tend=1): controller_params["logger_level"] = 15 controller_params["hook_class"] = [ LogSolution, - LogGlobalErrorPostRun, + LogRegisteredVar, + LogActiveRegisteredVar, + LogCompressionRatio, + LogCacheSize, + LogTimeCompression, + LogTimeDecompression, + LogCompCalls, + LogDecompCalls, + LogCacheInvalidates, + LogClearStats + # LogCacheHistory, # LogDatatypeCreations, ] # fill description dictionary for easy step instantiation description = {} - # description['problem_class'] = heatNd_forced# heat_ND_compressed + # description['problem_class'] = heatNd_forced description["problem_class"] = heat_ND_compressed description["problem_params"] = problem_params description["sweeper_class"] = imex_1st_order @@ -75,9 +92,7 @@ def run_heat(residual_tolerance=1e-4, errBound=1e-8, resolution=64, Tend=1): description["convergence_controllers"] = convergence_controllers # instantiate controller - controller = controller_nonMPI( - controller_params=controller_params, description=description, num_procs=1 - ) + controller = controller_nonMPI(controller_params=controller_params, description=description, num_procs=1) # get initial values on finest level P = controller.MS[0].levels[0].prob @@ -91,16 +106,122 @@ def run_heat(residual_tolerance=1e-4, errBound=1e-8, resolution=64, Tend=1): def main(): from pySDC.helpers.stats_helper import get_list_of_types, sort_stats, filter_stats + import pandas as pd - stats = run_heat(Tend=0.3) - error = max([me[1] for me in get_sorted(stats, type="e_global_post_run")]) + stats = run_heat(Tend=0.1) + # error = max([me[1] for me in get_sorted(stats, type="e_global_post_run")]) # print(get_list_of_types(stats)) # print("filter_stats", filter_stats(stats, type="u")) # print("sort_stats", sort_stats(filter_stats(stats, type="u"), sortby="time")) # u = get_sorted(stats, type="num_datatype_creations") # print(u) - print(error) + # print(error) # import matplotlib.pyplot as plt + u = get_sorted(stats, type="compression_ratio") + v = get_sorted(stats, type="num_registered_var") + w = get_sorted(stats, type="num_active_registered_var") + cs = get_sorted(stats, type="num_arrays_cache") + y = get_sorted(stats, type="num_comp_calls") + z = get_sorted(stats, type="num_decomp_calls") + time_comp_nocache = get_sorted(stats, type="execution_time_comp_nocache") # No cache + time_decomp_nocache = get_sorted(stats, type="execution_time_decomp_nocache") + time_comp = get_sorted( + stats, type="execution_time_comp" + ) # Time - not found in cache - compress, eviction maybe, add to cache (put) + time_decomp = get_sorted(stats, type="execution_time_decomp") + time_comp_update = get_sorted(stats, type="execution_time_comp_update") # Found in cache - update or get it + time_decomp_get = get_sorted(stats, type="decomp_time_get") + time_comp_eviction = get_sorted(stats, type="comp_time_eviction") # Eviction time for write back cache + time_decomp_eviction = get_sorted(stats, type="decomp_time_eviction") + time_comp_put = get_sorted(stats, type="comp_time_put") # Only put operation + time_decomp_put = get_sorted(stats, type="decomp_time_put") + t_comp = get_sorted(stats, type="total_time_comp") # Total time + t_decomp = get_sorted(stats, type="total_time_decomp") + cache_inv = get_sorted(stats, type="cache_invalidates") + # cache_hist = get_sorted(stats, type="cache_history") + iters = get_sorted(stats, type="niter") + # cache_hits = get_sorted(stats, type="cache_hits") + # cache_misses = get_sorted(stats, type="cache_misses") + print("Compression Ratio:") + print(u) + print("\nNumber of registered variables:") + print(v) + print("\nNumber of active registered variables:") + print(w) + print("\nNumber of compression calls:") + print(y) + print("\nNumber of decompression calls:") + print(z) + print("\nNumber of cache invalidates:") + print(cache_inv) + print("Wrapper compression time nocache:\n") + print(time_comp_nocache) + print("Wrapper decompression time nocache:\n") + print(time_decomp_nocache) + print("Wrapper compression time:\n") + print(time_comp) + print("Wrapper decompression time:\n") + print(time_decomp) + print("Wrapper compression time update:\n") + print(time_comp_update) + print("Wrapper decompression time get:\n") + print(time_decomp_get) + print("Wrapper compression time eviction:\n") + print(time_comp_eviction) + print("Wrapper decompression time eviction:\n") + print(time_decomp_eviction) + print("Wrapper compression time put:\n") + print(time_comp_put) + print("Wrapper decompression time put:\n") + print(time_decomp_put) + + x, comp_calls = zip(*y) + x, decomp_calls = zip(*z) + x, time_comp_nocache = zip(*time_comp_nocache) + x, time_comp = zip(*time_comp) + x, time_comp_update = zip(*time_comp_update) + x, time_comp_eviction = zip(*time_comp_eviction) + x, time_comp_put = zip(*time_comp_put) + + x, time_decomp_nocache = zip(*time_decomp_nocache) + x, time_decomp = zip(*time_decomp) + x, time_decomp_get = zip(*time_decomp_get) + x, time_decomp_eviction = zip(*time_decomp_eviction) + x, time_decomp_put = zip(*time_decomp_put) + x, cache_inv = zip(*cache_inv) + x, iters = zip(*iters) + x, t_comp = zip(*t_comp) + x, t_decomp = zip(*t_decomp) + df = { + 'Time Steps': x, + 'Compression Calls': comp_calls, + 'Decompression Calls': decomp_calls, + 'Compression Time (No Cache)': time_comp_nocache, + 'Compression Time (Cache)': time_comp, + 'Compression Time (Evictions)': time_comp_eviction, + 'Compression Time (Put)': time_comp_put, + 'Compression Time (Update)': time_comp_update, + 'Decompression Time (No Cache)': time_decomp_nocache, + 'Decompression Time (Cache)': time_decomp, + 'Decompression Time (Evictions)': time_decomp_eviction, + 'Decompression Time (Put)': time_decomp_put, + 'Decompression Time (Get)': time_decomp_get, + 'Total Time (compression)': t_comp, + 'Total Time (decompression)': t_decomp, + 'Cache Invalidates': cache_inv, + 'Number of iterations': iters, + } + data_frame = pd.DataFrame(df) + data_frame.to_csv("result_cache_size_he_" + str(cs[0][1]) + "_nolog_blosc.csv", index=False) + # print("Wrapper compression time:\n") + # print("Wrapper decompression time:\n") + # with open("result_cache_size_"+str(cs[0][1])+"_.txt",'w') as fp: + # fp.write(' '.join('{} {}'.format(x[0],x[1]) for x in cs)) + # fp.write('\n')#Number of Compression calls + # fp.write(' '.join('{} {}'.format(x[0],x[1]) for x in y)) + # fp.write('\n')#Number of Decompression calls + # fp.write(' '.join('{} {}'.format(x[0],x[1]) for x in z)) + # fp.close() # plt.plot([me[0] for me in u], [me[1] for me in u]) # plt.show() diff --git a/pySDC/projects/compression/log_cache_history.py b/pySDC/projects/compression/log_cache_history.py new file mode 100644 index 0000000000..5400e60727 --- /dev/null +++ b/pySDC/projects/compression/log_cache_history.py @@ -0,0 +1,32 @@ +from pySDC.core.Hooks import hooks + + +class LogCacheHistory(hooks): + """ + Store the compression ratio at the end of each step as "u". + """ + + def post_step(self, step, level_number): + """ + Record compression ratio at the end of the step + + Args: + step (pySDC.Step.step): the current step + level_number (int): the current level number + + Returns: + None + """ + super().post_step(step, level_number) + + L = step.levels[level_number] + + self.add_to_stats( + process=step.status.slot, + time=L.time + L.dt, + level=L.level_index, + iter=step.status.iter, + sweep=L.status.sweep, + type="cache_history", + value=L.u[0].manager.cacheHist, + ) diff --git a/pySDC/projects/compression/log_cache_invalidates.py b/pySDC/projects/compression/log_cache_invalidates.py new file mode 100644 index 0000000000..3698a60b3d --- /dev/null +++ b/pySDC/projects/compression/log_cache_invalidates.py @@ -0,0 +1,52 @@ +from pySDC.core.Hooks import hooks + + +class LogCacheInvalidates(hooks): + """ + Store the compression ratio at the end of each step as "u". + """ + + def post_step(self, step, level_number): + """ + Record compression ratio at the end of the step + + Args: + step (pySDC.Step.step): the current step + level_number (int): the current level number + + Returns: + None + """ + super().post_step(step, level_number) + + L = step.levels[level_number] + + self.add_to_stats( + process=step.status.slot, + time=L.time + L.dt, + level=L.level_index, + iter=step.status.iter, + sweep=L.status.sweep, + type="cache_invalidates", + value=L.u[0].manager.cacheManager.cacheInvalidates, + ) + + self.add_to_stats( + process=step.status.slot, + time=L.time + L.dt, + level=L.level_index, + iter=step.status.iter, + sweep=L.status.sweep, + type="cache_hits", + value=L.u[0].manager.cacheManager.cache_hits, + ) + + self.add_to_stats( + process=step.status.slot, + time=L.time + L.dt, + level=L.level_index, + iter=step.status.iter, + sweep=L.status.sweep, + type="cache_misses", + value=L.u[0].manager.cacheManager.cache_misses, + ) diff --git a/pySDC/projects/compression/log_clear_stats.py b/pySDC/projects/compression/log_clear_stats.py new file mode 100644 index 0000000000..bc769cc15d --- /dev/null +++ b/pySDC/projects/compression/log_clear_stats.py @@ -0,0 +1,41 @@ +from pySDC.core.Hooks import hooks + + +class LogClearStats(hooks): + """ + Store the solution at the end of each step as "u". + """ + + def post_step(self, step, level_number): + """ + Clears the stats at the end of each step that need to be cleared + + Args: + step (pySDC.Step.step): the current step + level_number (int): the current level number + + Returns: + None + """ + super().post_step(step, level_number) + L = step.levels[level_number] + + # Clear the variables and metrics required: + L.u[0].manager.num_active_registered_var = 0 + L.u[0].manager.registerVars_time = 0 + L.u[0].manager.compression_time_nocache = 0 + L.u[0].manager.decompression_time_nocache = 0 + L.u[0].manager.compression_time = 0 + L.u[0].manager.decompression_time = 0 + L.u[0].manager.compression_time_update = 0 + L.u[0].manager.compression_time_eviction = 0 + L.u[0].manager.compression_time_put_only = 0 + L.u[0].manager.decompression_time_get = 0 + L.u[0].manager.decompression_time_eviction = 0 + L.u[0].manager.decompression_time_put_only = 0 + L.u[0].manager.num_compression_calls = 0 + L.u[0].manager.num_decompression_calls = 0 + L.u[0].manager.cacheHist = [] + L.u[0].manager.cacheManager.cacheInvalidates = 0 + L.u[0].manager.cacheManager.cache_hits = 0 + L.u[0].manager.cacheManager.cache_misses = 0 diff --git a/pySDC/projects/compression/log_compression_ratio.py b/pySDC/projects/compression/log_compression_ratio.py new file mode 100644 index 0000000000..cd0de6e719 --- /dev/null +++ b/pySDC/projects/compression/log_compression_ratio.py @@ -0,0 +1,63 @@ +from pySDC.core.Hooks import hooks + + +class LogCompressionRatio(hooks): + """ + Store the compression ratio at the end of each step as "u". + """ + + def post_step(self, step, level_number): + """ + Record compression ratio at the end of the step + + Args: + step (pySDC.Step.step): the current step + level_number (int): the current level number + + Returns: + None + """ + super().post_step(step, level_number) + + L = step.levels[level_number] + + self.add_to_stats( + process=step.status.slot, + time=L.time + L.dt, + level=L.level_index, + iter=step.status.iter, + sweep=L.status.sweep, + type="compression_ratio", + value=L.u[0].manager.sumCompressionRatio(), + ) + + +class LogCacheSize(hooks): + """ + Store the compression ratio at the end of each step as "u". + """ + + def post_step(self, step, level_number): + """ + Record compression ratio at the end of the step + + Args: + step (pySDC.Step.step): the current step + level_number (int): the current level number + + Returns: + None + """ + super().post_step(step, level_number) + + L = step.levels[level_number] + + self.add_to_stats( + process=step.status.slot, + time=L.time + L.dt, + level=L.level_index, + iter=step.status.iter, + sweep=L.status.sweep, + type="num_arrays_cache", + value=len(L.u[0].manager.cacheManager.cache), + ) diff --git a/pySDC/projects/compression/log_num_comp_decomp_calls.py b/pySDC/projects/compression/log_num_comp_decomp_calls.py new file mode 100644 index 0000000000..82b9680ed2 --- /dev/null +++ b/pySDC/projects/compression/log_num_comp_decomp_calls.py @@ -0,0 +1,94 @@ +from pySDC.core.Hooks import hooks + + +class LogCompDecompCalls(hooks): + """ + Store the number of function calls for compression and decompression at the end of each step as "u". + """ + + def post_step(self, step, level_number): + """ + Record number of function calls at the end of the step + + Args: + step (pySDC.Step.step): the current step + level_number (int): the current level number + + Returns: + None + """ + super().post_step(step, level_number) + + L = step.levels[level_number] + + self.add_to_stats( + process=step.status.slot, + time=L.time + L.dt, + level=L.level_index, + iter=step.status.iter, + sweep=L.status.sweep, + type="num_comp_decomp_calls", + value=L.u[0].manager.num_compression_calls + L.u[0].manager.num_decompression_calls, + ) + + +class LogCompCalls(hooks): + """ + Store the number of function calls for compression at the end of each step as "u". + """ + + def post_step(self, step, level_number): + """ + Record number of function calls at the end of the step + + Args: + step (pySDC.Step.step): the current step + level_number (int): the current level number + + Returns: + None + """ + super().post_step(step, level_number) + + L = step.levels[level_number] + + self.add_to_stats( + process=step.status.slot, + time=L.time + L.dt, + level=L.level_index, + iter=step.status.iter, + sweep=L.status.sweep, + type="num_comp_calls", + value=L.u[0].manager.num_compression_calls, + ) + + +class LogDecompCalls(hooks): + """ + Store the number of function calls for decompression at the end of each step as "u". + """ + + def post_step(self, step, level_number): + """ + Record number of function calls at the end of the step + + Args: + step (pySDC.Step.step): the current step + level_number (int): the current level number + + Returns: + None + """ + super().post_step(step, level_number) + + L = step.levels[level_number] + + self.add_to_stats( + process=step.status.slot, + time=L.time + L.dt, + level=L.level_index, + iter=step.status.iter, + sweep=L.status.sweep, + type="num_decomp_calls", + value=L.u[0].manager.num_decompression_calls, + ) diff --git a/pySDC/projects/compression/log_num_registered_var.py b/pySDC/projects/compression/log_num_registered_var.py new file mode 100644 index 0000000000..dced1de346 --- /dev/null +++ b/pySDC/projects/compression/log_num_registered_var.py @@ -0,0 +1,63 @@ +from pySDC.core.Hooks import hooks + + +class LogRegisteredVar(hooks): + """ + Store the solution at the end of each step as "u". + """ + + def post_step(self, step, level_number): + """ + Record solution at the end of the step + + Args: + step (pySDC.Step.step): the current step + level_number (int): the current level number + + Returns: + None + """ + super().post_step(step, level_number) + + L = step.levels[level_number] + + self.add_to_stats( + process=step.status.slot, + time=L.time + L.dt, + level=L.level_index, + iter=step.status.iter, + sweep=L.status.sweep, + type="num_registered_var", + value=L.u[0].manager.num_registered_var, + ) + + +class LogActiveRegisteredVar(hooks): + """ + Store the solution at the end of each step as "u". + """ + + def post_step(self, step, level_number): + """ + Record solution at the end of the step + + Args: + step (pySDC.Step.step): the current step + level_number (int): the current level number + + Returns: + None + """ + super().post_step(step, level_number) + + L = step.levels[level_number] + + self.add_to_stats( + process=step.status.slot, + time=L.time + L.dt, + level=L.level_index, + iter=step.status.iter, + sweep=L.status.sweep, + type="num_active_registered_var", + value=len(L.u[0].manager.mem_map.keys()), + ) diff --git a/pySDC/projects/compression/log_time_metrics.py b/pySDC/projects/compression/log_time_metrics.py new file mode 100644 index 0000000000..6268bbcc2b --- /dev/null +++ b/pySDC/projects/compression/log_time_metrics.py @@ -0,0 +1,163 @@ +from pySDC.core.Hooks import hooks + + +class LogTimeCompression(hooks): + """ + Store the solution at the end of each step as "u". + """ + + def post_step(self, step, level_number): + """ + Record solution at the end of the step + + Args: + step (pySDC.Step.step): the current step + level_number (int): the current level number + + Returns: + None + """ + super().post_step(step, level_number) + + L = step.levels[level_number] + + self.add_to_stats( + process=step.status.slot, + time=L.time + L.dt, + level=L.level_index, + iter=step.status.iter, + sweep=L.status.sweep, + type="execution_time_comp_nocache", + value=L.u[0].manager.compression_time_nocache, + ) + + self.add_to_stats( + process=step.status.slot, + time=L.time + L.dt, + level=L.level_index, + iter=step.status.iter, + sweep=L.status.sweep, + type="execution_time_comp", + value=L.u[0].manager.compression_time, + ) + + self.add_to_stats( + process=step.status.slot, + time=L.time + L.dt, + level=L.level_index, + iter=step.status.iter, + sweep=L.status.sweep, + type="execution_time_comp_update", + value=L.u[0].manager.compression_time_update, + ) + + self.add_to_stats( + process=step.status.slot, + time=L.time + L.dt, + level=L.level_index, + iter=step.status.iter, + sweep=L.status.sweep, + type="comp_time_eviction", + value=L.u[0].manager.compression_time_eviction, + ) + + self.add_to_stats( + process=step.status.slot, + time=L.time + L.dt, + level=L.level_index, + iter=step.status.iter, + sweep=L.status.sweep, + type="comp_time_put", + value=L.u[0].manager.compression_time_put_only, + ) + + self.add_to_stats( + process=step.status.slot, + time=L.time + L.dt, + level=L.level_index, + iter=step.status.iter, + sweep=L.status.sweep, + type="total_time_comp", + value=L.u[0].manager.compression_time_update + L.u[0].manager.compression_time, + ) + + +class LogTimeDecompression(hooks): + """ + Store the solution at the end of each step as "u". + """ + + def post_step(self, step, level_number): + """ + Record solution at the end of the step + + Args: + step (pySDC.Step.step): the current step + level_number (int): the current level number + + Returns: + None + """ + super().post_step(step, level_number) + + L = step.levels[level_number] + + self.add_to_stats( + process=step.status.slot, + time=L.time + L.dt, + level=L.level_index, + iter=step.status.iter, + sweep=L.status.sweep, + type="execution_time_decomp_nocache", + value=L.u[0].manager.decompression_time_nocache, + ) + + self.add_to_stats( + process=step.status.slot, + time=L.time + L.dt, + level=L.level_index, + iter=step.status.iter, + sweep=L.status.sweep, + type="execution_time_decomp", + value=L.u[0].manager.decompression_time, + ) + + self.add_to_stats( + process=step.status.slot, + time=L.time + L.dt, + level=L.level_index, + iter=step.status.iter, + sweep=L.status.sweep, + type="decomp_time_eviction", + value=L.u[0].manager.decompression_time_eviction, + ) + + self.add_to_stats( + process=step.status.slot, + time=L.time + L.dt, + level=L.level_index, + iter=step.status.iter, + sweep=L.status.sweep, + type="decomp_time_get", + value=L.u[0].manager.decompression_time_get, + ) + + self.add_to_stats( + process=step.status.slot, + time=L.time + L.dt, + level=L.level_index, + iter=step.status.iter, + sweep=L.status.sweep, + type="decomp_time_put", + value=L.u[0].manager.decompression_time_put_only, + ) + + self.add_to_stats( + process=step.status.slot, + time=L.time + L.dt, + level=L.level_index, + iter=step.status.iter, + sweep=L.status.sweep, + type="total_time_decomp", + value=L.u[0].manager.decompression_time_get + L.u[0].manager.decompression_time, + ) diff --git a/pySDC/projects/compression/model_cache_compcalls.ipynb b/pySDC/projects/compression/model_cache_compcalls.ipynb new file mode 100644 index 0000000000..22eb7ae939 --- /dev/null +++ b/pySDC/projects/compression/model_cache_compcalls.ipynb @@ -0,0 +1,1174 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "223b9c8c-cd78-4ca2-9d11-e958cc15403c", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import os\n", + "import re\n", + "import sys\n", + "import random\n", + "import time\n", + "import glob\n", + "import pandas as pd\n", + "import csv\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "sns.set_theme(style=\"whitegrid\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "550f3161-d7c5-425f-900e-55cbf0f7b58c", + "metadata": {}, + "outputs": [], + "source": [ + "data_frame1 = pd.read_csv('result_cache_size_0_nolog_blosc.csv',index_col='Time Steps')\n", + "data_frame1[\"Normalized Compression Calls\"] = data_frame1[\"Compression Calls\"]/data_frame1[\"Number of iterations\"]\n", + "data_frame1[\"Normalized Decompression Calls\"] = data_frame1[\"Decompression Calls\"]/data_frame1[\"Number of iterations\"]\n", + "data_frame2 = pd.read_csv('result_cache_size_1_nolog_blosc.csv',index_col='Time Steps')\n", + "data_frame3 = pd.read_csv('result_cache_size_2_nolog_blosc.csv',index_col='Time Steps')\n", + "data_frame4 = pd.read_csv('result_cache_size_4_nolog_blosc.csv',index_col='Time Steps')\n", + "data_frame5 = pd.read_csv('result_cache_size_8_nolog_blosc.csv',index_col='Time Steps')\n", + "data_frame6 = pd.read_csv('result_cache_size_10_nolog_blosc.csv',index_col='Time Steps')\n", + "all_data_frames = [data_frame1,data_frame2,data_frame3,data_frame4,data_frame5,data_frame6]\n", + "for i in all_data_frames:\n", + " i[\"Normalized Compression Calls\"] = i[\"Compression Calls\"]/i[\"Number of iterations\"]\n", + " i[\"Normalized Decompression Calls\"] = i[\"Decompression Calls\"]/i[\"Number of iterations\"]\n", + " i[\"Compression Time (Cache compress)\"] = i[\"Compression Time (Cache)\"]-(i[\"Compression Time (Evictions)\"]+i[\"Compression Time (Put)\"])\n", + " i[\"Decompression Time (Cache decompress)\"] = i[\"Decompression Time (Cache)\"]-(i[\"Decompression Time (Evictions)\"]+i[\"Decompression Time (Put)\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "0e8155a9-0ae7-47b4-94e2-6944a507a1cb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Compression CallsDecompression CallsCompression Time (No Cache)Compression Time (Cache)Compression Time (Evictions)Compression Time (Put)Compression Time (Update)Decompression Time (No Cache)Decompression Time (Cache)Decompression Time (Evictions)Decompression Time (Put)Decompression Time (Get)Total Time (compression)Total Time (decompression)Cache InvalidatesNumber of iterationsNormalized Compression CallsNormalized Decompression CallsCompression Time (Cache compress)Decompression Time (Cache decompress)
Time Steps
0.001355846270.11764600000.41387500000009395.333333514.11111100
0.002355546250.11412900000.41305000000009395.000000513.88888900
0.003393251150.12621600000.445312000000010393.200000511.50000000
0.004355546250.11452200000.40608400000009395.000000513.88888900
0.005393251150.13553300000.478596000000010393.200000511.50000000
0.006393251150.13866900000.491914000000010393.200000511.50000000
0.007393251150.13798400000.491575000000010393.200000511.50000000
0.008393251150.14845100000.526501000000010393.200000511.50000000
0.009393251150.13712600000.484779000000010393.200000511.50000000
0.010393251150.12571000000.448107000000010393.200000511.50000000
\n", + "
" + ], + "text/plain": [ + " Compression Calls Decompression Calls \\\n", + "Time Steps \n", + "0.001 3558 4627 \n", + "0.002 3555 4625 \n", + "0.003 3932 5115 \n", + "0.004 3555 4625 \n", + "0.005 3932 5115 \n", + "0.006 3932 5115 \n", + "0.007 3932 5115 \n", + "0.008 3932 5115 \n", + "0.009 3932 5115 \n", + "0.010 3932 5115 \n", + "\n", + " Compression Time (No Cache) Compression Time (Cache) \\\n", + "Time Steps \n", + "0.001 0.117646 0 \n", + "0.002 0.114129 0 \n", + "0.003 0.126216 0 \n", + "0.004 0.114522 0 \n", + "0.005 0.135533 0 \n", + "0.006 0.138669 0 \n", + "0.007 0.137984 0 \n", + "0.008 0.148451 0 \n", + "0.009 0.137126 0 \n", + "0.010 0.125710 0 \n", + "\n", + " Compression Time (Evictions) Compression Time (Put) \\\n", + "Time Steps \n", + "0.001 0 0 \n", + "0.002 0 0 \n", + "0.003 0 0 \n", + "0.004 0 0 \n", + "0.005 0 0 \n", + "0.006 0 0 \n", + "0.007 0 0 \n", + "0.008 0 0 \n", + "0.009 0 0 \n", + "0.010 0 0 \n", + "\n", + " Compression Time (Update) Decompression Time (No Cache) \\\n", + "Time Steps \n", + "0.001 0 0.413875 \n", + "0.002 0 0.413050 \n", + "0.003 0 0.445312 \n", + "0.004 0 0.406084 \n", + "0.005 0 0.478596 \n", + "0.006 0 0.491914 \n", + "0.007 0 0.491575 \n", + "0.008 0 0.526501 \n", + "0.009 0 0.484779 \n", + "0.010 0 0.448107 \n", + "\n", + " Decompression Time (Cache) Decompression Time (Evictions) \\\n", + "Time Steps \n", + "0.001 0 0 \n", + "0.002 0 0 \n", + "0.003 0 0 \n", + "0.004 0 0 \n", + "0.005 0 0 \n", + "0.006 0 0 \n", + "0.007 0 0 \n", + "0.008 0 0 \n", + "0.009 0 0 \n", + "0.010 0 0 \n", + "\n", + " Decompression Time (Put) Decompression Time (Get) \\\n", + "Time Steps \n", + "0.001 0 0 \n", + "0.002 0 0 \n", + "0.003 0 0 \n", + "0.004 0 0 \n", + "0.005 0 0 \n", + "0.006 0 0 \n", + "0.007 0 0 \n", + "0.008 0 0 \n", + "0.009 0 0 \n", + "0.010 0 0 \n", + "\n", + " Total Time (compression) Total Time (decompression) \\\n", + "Time Steps \n", + "0.001 0 0 \n", + "0.002 0 0 \n", + "0.003 0 0 \n", + "0.004 0 0 \n", + "0.005 0 0 \n", + "0.006 0 0 \n", + "0.007 0 0 \n", + "0.008 0 0 \n", + "0.009 0 0 \n", + "0.010 0 0 \n", + "\n", + " Cache Invalidates Number of iterations \\\n", + "Time Steps \n", + "0.001 0 9 \n", + "0.002 0 9 \n", + "0.003 0 10 \n", + "0.004 0 9 \n", + "0.005 0 10 \n", + "0.006 0 10 \n", + "0.007 0 10 \n", + "0.008 0 10 \n", + "0.009 0 10 \n", + "0.010 0 10 \n", + "\n", + " Normalized Compression Calls Normalized Decompression Calls \\\n", + "Time Steps \n", + "0.001 395.333333 514.111111 \n", + "0.002 395.000000 513.888889 \n", + "0.003 393.200000 511.500000 \n", + "0.004 395.000000 513.888889 \n", + "0.005 393.200000 511.500000 \n", + "0.006 393.200000 511.500000 \n", + "0.007 393.200000 511.500000 \n", + "0.008 393.200000 511.500000 \n", + "0.009 393.200000 511.500000 \n", + "0.010 393.200000 511.500000 \n", + "\n", + " Compression Time (Cache compress) \\\n", + "Time Steps \n", + "0.001 0 \n", + "0.002 0 \n", + "0.003 0 \n", + "0.004 0 \n", + "0.005 0 \n", + "0.006 0 \n", + "0.007 0 \n", + "0.008 0 \n", + "0.009 0 \n", + "0.010 0 \n", + "\n", + " Decompression Time (Cache decompress) \n", + "Time Steps \n", + "0.001 0 \n", + "0.002 0 \n", + "0.003 0 \n", + "0.004 0 \n", + "0.005 0 \n", + "0.006 0 \n", + "0.007 0 \n", + "0.008 0 \n", + "0.009 0 \n", + "0.010 0 " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "all_data_frames[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "abe4c956-41e6-4ecc-98e3-eee246acd7c8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Compression Calls 3819.200000\n", + "Decompression Calls 4968.200000\n", + "Compression Time (No Cache) 0.129599\n", + "Compression Time (Cache) 0.000000\n", + "Compression Time (Evictions) 0.000000\n", + "Compression Time (Put) 0.000000\n", + "Compression Time (Update) 0.000000\n", + "Decompression Time (No Cache) 0.459979\n", + "Decompression Time (Cache) 0.000000\n", + "Decompression Time (Evictions) 0.000000\n", + "Decompression Time (Put) 0.000000\n", + "Decompression Time (Get) 0.000000\n", + "Total Time (compression) 0.000000\n", + "Total Time (decompression) 0.000000\n", + "Cache Invalidates 0.000000\n", + "Number of iterations 9.700000\n", + "Normalized Compression Calls 393.773333\n", + "Normalized Decompression Calls 512.238889\n", + "Compression Time (Cache compress) 0.000000\n", + "Decompression Time (Cache decompress) 0.000000\n", + "dtype: float64" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "all_data_frames2 = all_data_frames[0].mean()\n", + "all_data_frames3 = all_data_frames[1].mean()\n", + "all_data_frames4 = all_data_frames[2].mean()\n", + "all_data_frames5 = all_data_frames[3].mean()\n", + "all_data_frames6 = all_data_frames[4].mean()\n", + "all_data_frames7 = all_data_frames[5].mean()\n", + "all_data_frames2" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "4984df01-2b71-4d56-a5f6-963c277e6e6c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Compression Calls 3723.800000\n", + "Decompression Calls 4346.300000\n", + "Compression Time (No Cache) 0.000000\n", + "Compression Time (Cache) 0.315685\n", + "Compression Time (Evictions) 0.133766\n", + "Compression Time (Put) 0.018586\n", + "Compression Time (Update) 0.000273\n", + "Decompression Time (No Cache) 0.000000\n", + "Decompression Time (Cache) 0.649713\n", + "Decompression Time (Evictions) 0.176866\n", + "Decompression Time (Put) 0.016658\n", + "Decompression Time (Get) 0.001811\n", + "Total Time (compression) 0.315958\n", + "Total Time (decompression) 0.651523\n", + "Cache Invalidates 8039.800000\n", + "Number of iterations 9.700000\n", + "Normalized Compression Calls 383.935556\n", + "Normalized Decompression Calls 448.116667\n", + "Compression Time (Cache compress) 0.163333\n", + "Decompression Time (Cache decompress) 0.456188\n", + "dtype: float64" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "all_data_frames3" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "c3dc06ce-ecfc-4c33-834b-837e069eba0f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Compression Calls 3723.800000\n", + "Decompression Calls 4346.300000\n", + "Compression Time (No Cache) 0.000000\n", + "Compression Time (Cache) 0.311255\n", + "Compression Time (Evictions) 0.131076\n", + "Compression Time (Put) 0.017063\n", + "Compression Time (Update) 0.000281\n", + "Decompression Time (No Cache) 0.000000\n", + "Decompression Time (Cache) 0.636452\n", + "Decompression Time (Evictions) 0.175907\n", + "Decompression Time (Put) 0.015456\n", + "Decompression Time (Get) 0.001960\n", + "Total Time (compression) 0.311537\n", + "Total Time (decompression) 0.638412\n", + "Cache Invalidates 8039.700000\n", + "Number of iterations 9.700000\n", + "Normalized Compression Calls 383.935556\n", + "Normalized Decompression Calls 448.116667\n", + "Compression Time (Cache compress) 0.163116\n", + "Decompression Time (Cache decompress) 0.445088\n", + "dtype: float64" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "all_data_frames4" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "28805036-a9c1-4095-b092-5a15d5392feb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Compression Calls 3721.500000\n", + "Decompression Calls 4185.000000\n", + "Compression Time (No Cache) 0.000000\n", + "Compression Time (Cache) 0.312905\n", + "Compression Time (Evictions) 0.132713\n", + "Compression Time (Put) 0.018508\n", + "Compression Time (Update) 0.000276\n", + "Decompression Time (No Cache) 0.000000\n", + "Decompression Time (Cache) 0.621786\n", + "Decompression Time (Evictions) 0.169842\n", + "Decompression Time (Put) 0.016035\n", + "Decompression Time (Get) 0.002247\n", + "Total Time (compression) 0.313181\n", + "Total Time (decompression) 0.624033\n", + "Cache Invalidates 7874.100000\n", + "Number of iterations 9.700000\n", + "Normalized Compression Calls 383.695556\n", + "Normalized Decompression Calls 431.477778\n", + "Compression Time (Cache compress) 0.161683\n", + "Decompression Time (Cache decompress) 0.435909\n", + "dtype: float64" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "all_data_frames5" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "73160b64-36b9-4bbb-ac53-a1049d82d58f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Compression Calls 3265.900000\n", + "Decompression Calls 3068.100000\n", + "Compression Time (No Cache) 0.000000\n", + "Compression Time (Cache) 0.313991\n", + "Compression Time (Evictions) 0.128566\n", + "Compression Time (Put) 0.017671\n", + "Compression Time (Update) 0.001823\n", + "Decompression Time (No Cache) 0.000000\n", + "Decompression Time (Cache) 0.504743\n", + "Decompression Time (Evictions) 0.137289\n", + "Decompression Time (Put) 0.012294\n", + "Decompression Time (Get) 0.005735\n", + "Total Time (compression) 0.315815\n", + "Total Time (decompression) 0.510478\n", + "Cache Invalidates 5831.600000\n", + "Number of iterations 9.700000\n", + "Normalized Compression Calls 336.728889\n", + "Normalized Decompression Calls 316.314444\n", + "Compression Time (Cache compress) 0.167755\n", + "Decompression Time (Cache decompress) 0.355160\n", + "dtype: float64" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "all_data_frames6" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "9633c23a-3d4f-46ad-90bc-5ffa73148d17", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Compression Calls 2124.100000\n", + "Decompression Calls 650.200000\n", + "Compression Time (No Cache) 0.000000\n", + "Compression Time (Cache) 0.140848\n", + "Compression Time (Evictions) 0.037558\n", + "Compression Time (Put) 0.009855\n", + "Compression Time (Update) 0.005211\n", + "Decompression Time (No Cache) 0.000000\n", + "Decompression Time (Cache) 0.097726\n", + "Decompression Time (Evictions) 0.015919\n", + "Decompression Time (Put) 0.002224\n", + "Decompression Time (Get) 0.009729\n", + "Total Time (compression) 0.146059\n", + "Total Time (decompression) 0.107454\n", + "Cache Invalidates 1129.200000\n", + "Number of iterations 9.700000\n", + "Normalized Compression Calls 219.001111\n", + "Normalized Decompression Calls 67.025556\n", + "Compression Time (Cache compress) 0.093436\n", + "Decompression Time (Cache decompress) 0.079583\n", + "dtype: float64" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "all_data_frames7" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "047e99fc-3e5a-411d-9b2f-aa812560f67f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Compression Calls')" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cache_size = [1,2,4,8,16]\n", + "ax = all_data_frames[0].plot(y='Normalized Compression Calls',label='No Cache')\n", + "for i in range(1,len(all_data_frames)):\n", + " all_data_frames[i].plot(ax=ax,y='Normalized Compression Calls',label='Cache Size'+str(cache_size[i-1]))\n", + "plt.xlabel('Time step (s)')\n", + "plt.ylabel('Compression Calls')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "c5121f23-cae2-4378-b92f-c5affc296285", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Decompression Calls')" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cache_size = [1,2,4,8,16]\n", + "ax = all_data_frames[0].plot(y='Normalized Decompression Calls',label='No Cache')\n", + "for i in range(1,len(all_data_frames)):\n", + " all_data_frames[i].plot(ax=ax,y='Normalized Decompression Calls',label='Cache Size'+str(cache_size[i-1]))\n", + "plt.xlabel('Time step (s)')\n", + "plt.ylabel('Decompression Calls')" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "3b7799a1-f208-4c2f-be12-7d5ea35dccd0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "all_df = []\n", + "df = pd.DataFrame({'Compression Time (No Cache compress)':all_data_frames[0]['Compression Time (No Cache)']})\n", + "df.plot(kind='bar', stacked=True, color=['red'])\n", + "plt.ylabel('Time (s)')\n", + "plt.title('Compression Time Overhead for No Cache')\n", + "plt.savefig('Comp_time_no_cache.png')\n", + "all_df.append(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a361f88f-b316-4dbf-b9c7-45545870f699", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# create stacked bar chart for monthly temperatures\n", + "for i in range(1,len(all_data_frames)):\n", + " df = pd.DataFrame({'Compression Time (Cache compress)':all_data_frames[i]['Compression Time (Cache compress)'],'Compression Time (Put)':all_data_frames[i]['Compression Time (Put)'],'Compression Time (Evictions)':all_data_frames[i]['Compression Time (Evictions)']})\n", + " df.plot(kind='bar', stacked=True, color=['red', 'skyblue', 'green'])\n", + " plt.ylabel('Time (s)')\n", + " plt.title('Compression Time Overhead Breakdown with Cache Size '+str(cache_size[i-1]))\n", + " plt.savefig('Comp_time_cache_size_'+str(cache_size[i-1])+'.png')\n", + " all_df.append(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "9b5d736d-2db1-485a-84ec-e976366647ea", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "all_df = []\n", + "df = pd.DataFrame({'Decompression Time (No Cache decompress)':all_data_frames[0]['Decompression Time (No Cache)']})\n", + "df.plot(kind='bar', stacked=True, color=['red'])\n", + "plt.ylabel('Time (s)')\n", + "plt.title('Decompression Time Overhead for No Cache')\n", + "plt.savefig('Decomp_time_no_cache.png')\n", + "all_df.append(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "640e9184-0eae-4b1e-a903-00bda445999d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhkAAAExCAYAAADRDbBNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABfRElEQVR4nO3dd3yN5//H8VdysiShZiJKa1SG2RCJFUEURcSmVlVLaTVVVWLPIqp8jdIapWiromaoqlo1a5PaeyQSEiN7nNy/P8L9S8iUnOSWfJ6Ph8dDzrnPfb/Pfc65z+dc13Xfl5GiKApCCCGEELnMOL8DCCGEEKJgkiJDCCGEEAYhRYYQQgghDEKKDCGEEEIYhBQZQgghhDAIKTKEEEIIYRBSZOSSY8eO0apVqzzdZlBQEM7Ozuj1+jzdbl64c+cODg4OJCYmGnxb69ev57333jP4drLiyJEjNGnSJMvLOzg4cPPmTQMmyrm8fC0N7a+//sLDwwNnZ2fOnTuXZ9vNbB+2bduWI0eO5FmejMyfP5/hw4fn6TY/+ugjNmzYkO79vr6+zJkzJw8Tpa1Pnz74+/sbfDubN2+mf//+Bt9OVphktkDz5s158OABOp0OnU7HW2+9hbe3N927d8fYWGqUZ1xcXPjzzz9zdZ3Hjh1jwIABACiKQkxMDJaWlur9W7du5eTJk7m6zYzs3r2b7777jitXrmBubk7jxo356quvKFu2bJ5lyGt37tzB09NT3e9FihShZcuWjBkzBlNT03xOJ3JTnz59aN++PV27dk13GT8/P8aNG0eLFi3yMFnmtm7dmt8R8tXSpUvV/69fvx5/f39+/fXXl15ffHw8P/zwA1u2bCE0NJSSJUvi5ubGp59+Svny5XMjco4dO3aMWbNmcfnyZXQ6HZUrV2b06NHUqlWL9u3b0759+1zd3qVLl/Dz8yMwMJBHjx5x8eLFLD0uS1XC999/z8mTJ9m9ezcDBgxgyZIljBkzJkeB89Or8ovKxcWFkydPcvLkSQICAgA4evSoelu5cuXyLMv27dv58ssv6du3L4cPHyYgIAAzMzN69uzJ48ePc3VbWnx9nu33LVu2cOrUKX7++ec0l9NidpF7goKCqFq1an7HEAbm4+PDrl27mDVrFseOHWPTpk3UqFGDQ4cO5Xc0ACIjIxk0aBC9e/fm33//Zd++fQwZMgQzMzODbdPExITWrVvz9ddfZ+tx2WqKKFq0KJ6envzvf/9jw4YNXLp0CUiu+vz8/GjatCkNGzZk/PjxxMbGqo/buXMn3t7e1KlThxYtWrBv3z4AQkJCGDRoEK6urrzzzjusXbtWfcz8+fPx8fFh+PDhODs74+XlxfXr1/nhhx9o0KABHh4e7N+/X12+T58+fPvtt3Tp0oW6desyePBgHj16BPx/U6O/vz9Nmzbl/fffB2DdunW8++671KtXjw8//JC7d+8Cya0G06ZNo0GDBtStWxcvLy/1ue7du5c2bdrg7OyMu7s7y5YtA15s5r569Sp9+vTBxcWFtm3b8vfff6v3+fr6MmnSJAYOHIizszNdu3bl1q1b2XkpUj2vZ19sffr0Yc6cOfTo0QNnZ2cGDRrEw4cP+fLLL6lTpw6dO3fmzp07qTJ+8MEHuLq60qpVK7Zt25bmdhRFwc/Pj8GDB9O+fXssLCwoU6YMX3/9NZaWlqxYsYL4+HhcXFzU/QQQHh5OrVq1CAsLA5JbQry9vXFxcaFHjx5cuHBBXbZ58+YsXrwYLy8v3n77bbULaMuWLTRt2hQ3NzcWLVqkLp+UlMTixYtp0aIFbm5ufP755+rrDckHiUaNGlG3bl169erF5cuX1fsePnzIoEGDqFOnDl26dMnWvi9VqhQNGzbk6tWr6WZPTEzk1KlT9OjRAxcXF9q3b5+qKfv333/n3XffxdnZGU9PT9asWZPu9lauXEmbNm24d+8ekPyLrXHjxjRu3Jh169alWjYiIoIRI0ZQv359mjVrxsKFC0lKSgKgWbNmBAYGArBp0yYcHBy4cuUKAP7+/nzyySdA8ufu888/Z8SIETg7O9O2bVvOnj2bZrZ58+YxZcoUABISEnj77beZOXMmALGxsdSsWTNVAfoyr+Wz9/iGDRvSfOzzMvtsnThxgs6dO1O3bl06d+7MiRMnAJgzZw7Hjh1j8uTJODs7M3ny5FTrjY+PV7smvb291ZaMjD7nzzeNP98t5+DgwK+//krLli2pV68ekyZN4tkFmPV6PX5+fri5ueHp6cnevXvTfc6Q/B48ePAgkL3XEODy5cvqcaBhw4Z8//33AJw5c4bu3bvj4uJC48aNmTx5MvHx8Zk+DpLfD+ltPyQkhM8++4z69evTvHlzVq5cmWau27dv4+Lior6Hx4wZQ4MGDdT7hw8fzooVK1Lt66tXrzJhwgROnTqFs7MzLi4u6vJPnjzJ0jH34MGDHDx4kIULF1KrVi1MTEwoWrQovXr1Ulu5MvsMp/edB3D37l31GN2/f3/Cw8PV+zI6bqR0/fp1ANq1a4dOp8PCwoLGjRvj6OgIpH6vLVmyBGdnZ/Vf9erV8fX1BZKPGaNHj6Zx48a4u7szZ86cdLvfK1euTNeuXbNfZCuZaNasmXLgwIEXbvfw8FB+/vlnRVEUZerUqcrHH3+sPHz4UImIiFA+/vhjZdasWYqiKMrp06eVOnXqKPv371f0er1y79495cqVK4qiKEqvXr2UCRMmKLGxscq5c+cUNzc35eDBg4qiKMq8efOUGjVqKPv27VMSEhKUr776SmnWrJmycOFCJT4+Xvntt9+UZs2aqXl69+6tNG7cWLl48aISFRWlDBkyRPnyyy8VRVGU27dvK/b29spXX32lREVFKTExMcpff/2ltGjRQrly5YqSkJCgfPfdd0r37t0VRVGUffv2KR07dlQeP36sJCUlKVeuXFFCQkIURVGURo0aKUePHlUURVEePXqkBAYGKoqiKIcPH1bc3d0VRVGU+Ph4pUWLFsqiRYuUuLg45eDBg8rbb7+tXL16VVEURRk5cqRSr1495fTp00pCQoIybNgwZejQoRm+Ds+eQ0JCQrq39e7dW2nRooVy8+ZN5cmTJ8q7776rtGzZUjlw4IC6D319fRVFUZSoqCilSZMmyrp165SEhAQlMDBQcXV1VS5duvTCtq9cuaLY29srt27deuG+uXPnKt26dVMURVF8fX2V2bNnq/etXr1a6d+/v6IoihIYGKjUr19fOXXqlJKYmKisX79eadasmRIXF6coSvL7rH379kpQUJASExOjPrcxY8YoMTExyvnz55Xq1aur753ly5crXbt2VYKDg5W4uDhl3LhxyhdffKFu29/fX4mIiFDi4uKUqVOnKu3bt1fvGzp0qOLj46NERUUpFy9eVBo3bqz06NEjS/v93r17ipeXl+Lv768u83z2e/fuKa6ursqePXsUvV6v7N+/X3F1dVXCwsIURVGU3bt3Kzdv3lSSkpKUI0eOKLVq1UrzfbRgwQKlQ4cO6uP27t2rNGjQQH2PDxs2TLG3t1du3LihKIqifPXVV8qgQYOUiIgI5fbt20rLli2VtWvXqvctW7ZMURRFGTt2rOLp6al+fr/66itl+fLliqL8/+duz549SmJiojJr1iyla9euae6bgwcPKu3atVMURVGOHz+ueHp6Kl26dFHv8/LySrUPX+a1zOyxz8vos/Xw4UPFxcVF2bBhg5KQkKBs2bJFcXFxUcLDwxVFSf78PNtf6Um5vzP7nD+/vt9//z3V+8ze3l4ZOHCg8vjxY+Xu3buKm5ubsnfvXkVRFOWXX35RWrVqpQQFBSkPHz5Uevfu/cLnP6WUx+nsvIYRERFKo0aNlGXLlimxsbFKRESEcurUKUVRFOXs2bPKyZMnlYSEBOX27dtK69at1fdJRo/LaPt6vV7p2LGjMn/+fCUuLk65deuW0rx5c2Xfvn1p5vPw8FDOnj2rKIqitGzZUmnevLn62nt4eCj//fffC/v6+f2sKNk75n7zzTdKr1690rzvmYw+wxl95/Xu3Vvx9PRUrl27psTExCi9e/dWvvnmG0VRlEyPG8+/bq6ursqIESOUPXv2KI8ePUp1f1r7QFEUJSgoSGnUqJGyZ88eRVEUZfDgwcq4ceOUqKgo5cGDB0rnzp2VX3/9NcPnfuPGDcXe3j7DZVJ66UEVNjY2PH78GEVR8Pf3Z/To0RQvXhxra2s+/vhjtY9w3bp1dO7cmUaNGmFsbIytrS1VqlQhODiY48ePM3z4cMzNzXFycqJr165s2rRJ3YaLiwvu7u5qM83Dhw8ZOHAgpqamtGnThrt37/LkyRN1eW9vb+zt7bG0tOTzzz9n+/btqaqyzz77DEtLSywsLFizZg0DBw6kSpUqmJiYMGjQIM6fP8/du3cxMTEhKiqKa9euoSgKVapUwcbGBkhuMrpy5QqRkZG89tprVK9e/YV9c/r0aaKjoxk4cCBmZmY0aNCAZs2apeo3feedd9QquX379pw/f/5lX4pUOnXqxBtvvEHRokVp0qQJFSpUoGHDhuo+fDZYbc+ePbz++ut07twZExMTqlevTqtWrdIcV/Lw4UMAdR+kVKZMGfV+Ly8vtVsHkn+5enl5AbB27Vq6d+9O7dq10el0dOzYEVNTU06dOqUu36dPH+zs7LCwsFBvGzJkCBYWFjg6OuLo6Ki2fvz222988cUXlC1bFjMzM4YMGcKff/6ptup06dIFa2trzMzM+Oyzz7hw4QIRERHo9Xp27NiBj48PlpaW2Nvb07Fjx0z3a/369XFxcaFJkyZYWlrSunXrVPenzL5p0yaaNGmCh4cHxsbGNGrUiBo1aqi/Rps2bcobb7yBkZERrq6uNGrUiGPHjqnrUhSF6dOns3//flauXEnJkiUB+OOPP+jUqZP6Hh8yZIj6GL1ez7Zt2/jyyy+xtramfPnyfPDBB2zevBmAevXq8e+//wLJfbkff/wxR48eBZK7gurVq6euq27dunh4eKDT6fD29k7V4pSSs7MzN27c4OHDhxw7dowuXboQEhJCVFQUR48exdXVNdXyL/taZvTYtKT32dqzZw9vvvkmHTp0wMTEhHbt2lG5cmV2796d7roykpXPeWYGDBhAsWLFKFeuHG5uburz+uOPP3j//fexs7OjePHifPzxx9nKltXXcM+ePZQuXZr+/ftjbm6OtbU1tWvXBqBGjRq8/fbbmJiYUL58ebp3766+ZzJ6XEbbP3v2LOHh4WrTfoUKFejWrVu6raj16tXj6NGj3L9/H4BWrVrx77//cvv2bSIjI9Vf7lmR1WPuo0ePKFOmTIbryugznN533jOdOnWiUqVKWFhY0Lp1azVHZseNlKytrfnll18wMjJi3LhxNGjQgEGDBvHgwYN0M8fGxvLpp5/St29fPDw8ePDgAfv27WP06NFYWlpSqlQp+vXrl+vjezId+JmekJAQXnvtNcLDw4mJiaFTp07qfYqiqE1cwcHBeHh4vPD40NBQXnvtNaytrdXbypUrpzbpQnLT9DMWFhaUKFECnU6n/g0QHR1NsWLFALCzs0u1roSEBPULEEg1QDEoKIhp06bh5+eXKndISAgNGjSgV69eTJ48maCgIN555x1GjhyJtbU18+bNY9GiRXz77bc4ODjw5Zdf4uzs/MJzK1u2bKqBseXKlSMkJET9u3Tp0qmeW3R09Av76GWkXK+5uXm627l79y5nzpxJ1Zyo1+vTHCxUokQJIPl5VahQIdV99+/fV++vX78+cXFxnD59mtKlS3PhwgW1WTkoKIiNGzeyevVq9bEJCQmEhoaqf6d8/dJ6PkWKFFHzBwUF8emnn6bax8bGxoSFhVG6dGnmzJnD9u3bCQ8PV5d5+PAhsbGxJCYmvvBeyczhw4cxMTEhNjaWuXPn8tFHH6VqIk25vqCgILZv357qyysxMRE3Nzcgucvtu+++48aNGyQlJREbG4u9vb26bEREBGvXrmXOnDkULVpUvT00NJQaNWqof7/++uvq/x8+fEhCQkKq55LyPefq6srMmTO5f/8+SUlJvPvuuyxYsIA7d+4QERGBk5NTmvvcwsKCuLg4EhMTMTFJfbiwsLCgRo0aHD16lKNHj6qF+okTJzh69Ci9e/dOtfzLvJaZPTYt6b3nQ0NDX3itn/9cZkdWPueZSfllVqRIEaKiotR1Z/c9mlJWX8Pg4GDeeOONNNdx/fp1ZsyYQWBgIDExMej1evVHVUaPy2j7d+/eJTQ09IXjTsq/U3J1deXvv//G1taWevXq4ebmxqZNmzA3N8fFxSVbJx9k9ZhbvHhxbty4keG6MvoMp/ed98zzr3nKz0FGx43nValShRkzZgDJ3XZfffUV06ZNY/bs2WkuP2bMGCpVqsTAgQPV7SUmJtK4cWN1maSkpDSPwznxUkXGmTNnCAkJoW7dupQoUQILCwu2bt2Kra3tC8va2dml2ff1rCUkMjJSLTSCg4PTXEdWBQcHp/q/qakpJUqUUG83MjJKlWvQoEHpjsDt27cvffv2JSwsjKFDh7J06VKGDh1KrVq1WLRoEQkJCfz8888MHTr0hUrTxsaGe/fukZSUpH4IgoODqVix4ks/t9xmZ2dHvXr1WL58eabLVq5cmbJly7J9+3b1bBdIfkPu2LEDT09PIPmLoXXr1gQEBFC6dGmaNm2qvrbP9vfgwYPT3U7K1yczZcuWZdq0adStW/eF+zZu3Mjff//N8uXLKV++PBEREdSrVw9FUShZsiQmJiYEBwervy5Svm8yY2FhQadOnfjxxx8JDw9XWxmef295e3szderUFx4fHx+Pj48Pfn5+eHp6YmpqyieffKL2xQMUK1aMb775hqFDh7JgwQL1OdrY2KTKGhQUpP6/RIkSmJqaEhQUxFtvvaU+r2efpzfffBMLCwtWrVqFi4sL1tbWlC5dmrVr11K3bt2XPlPM1dWVw4cPc/78eWrWrImrqyv79+/nzJkzqVpHMpLRa5lyDFFO2djYpNpnkLyP3N3dX3p9GX3OixQpQkxMjLp8Rr8yn1emTJkXjmeGYGdnl+4v14kTJ1KtWjW+/fZbrK2tWbFihdrSmdHjMtte+fLl2bFjR5aWr1evHjNnzqRs2bLUq1ePunXrMmHCBMzNzdN9f2XnOJKWhg0bsnLlSu7du5fmmXOZfYbT+87LTEbHjcxUqVKFTp068dtvv6V5/+LFi7l+/Tq//PKLetuzlsNnP6AMJVtHlsjISHbv3s2wYcNo3749Dg4OGBsb07VrV6ZNm6b+8ggJCeGff/4Bkput169fz6FDh0hKSiIkJISrV69iZ2eHs7Mzs2fPJi4ujgsXLrBu3Tq1ef1lbN68mStXrhATE8PcuXNp1aqV2vLxvB49erB48WJ1QGBERAR//PEHkFxEnT59moSEBIoUKYKZmRk6nY74+Hg2b95MREQEpqamWFlZpbn+WrVqUaRIEZYuXUpCQgJHjhxh165dtGnT5qWfW25r2rQpN27cYOPGjSQkJJCQkMCZM2dSDWh8xsjIiJEjR7Jo0SK2bNlCbGws9+/fZ8yYMURGRtKvXz91WS8vL/744w+2bNlCu3bt1Nu7du3KmjVrOH36NIqiEB0dzZ49e4iMjHyp/O+99x7/+9//1MG64eHh7Ny5E4CoqCjMzMwoUaIEMTExqSp7nU7HO++8w4IFC4iJieHKlSsZnl//vPj4eDZt2kSZMmXUFpzntW/fnt27d/PPP/+g1+uJi4vjyJEj3Lt3j/j4eOLj49ViZ+/evRw4cOCFdbi5uTFr1iyGDBnC6dOnAWjdujUbNmxQ3+MLFixI9bxat27NnDlziIyM5O7duyxfvjxVEe3q6srq1avVg/Pzf7+MevXqsXHjRqpUqYKZmRmurq74+/tTvnx5tQDLTEavZW7y8PDgxo0bbNmyhcTERLZt28aVK1do2rQpkPxL9/bt21leX2afcycnJ/766y9iYmK4efPmCwN1M/Luu++yatUq7t27x+PHj1m8eHG2nmtWNW3alAcPHqiDtyMjI9X3W1RUFFZWVlhZWXH16tVUp4Rm9LiM1KpVC2traxYvXkxsbCx6vZ5Lly5x5syZNJevWLEi5ubmbN68mXr16mFtbU2pUqX4888/033flipVipCQkFSDVLOjYcOGNGzYkE8//ZTAwEASExOJjIzk119/Zd26dZl+htP7zstMRseN5129epUff/xRvS84OJiAgIBUXVbP7N27l5UrV/Ldd9+l6oq2sbGhUaNGzJgxg8jISJKSkrh165barfo8RVGIi4sjISEBgLi4uCzt4ywVGYMGDcLZ2RkPDw++//57PvjgA6ZPn67e/9VXX/Hmm2/SrVs36tSpQ79+/dTRr7Vq1WL69OnqL5XevXurvyZmz57N3bt3cXd3Z8iQIXz22Wc0atQoK5HS5O3tja+vL40aNSI+Pj7D02zfeecdPvroI4YNG0adOnVo166dOgI4KiqKsWPH4urqSrNmzShevLh6YZNNmzbRvHlz6tSpw5o1a9TR9CmZmZmxaNEi9u3bR/369Zk0aRIzZ85M1S+X36ytrVm2bBnbtm3D3d2dxo0bM2vWrHTfNG3atGHmzJmsWLGC+vXr07ZtW+Li4vj1119TfdnWrl2bIkWKEBoamupsm5o1azJlyhQmT55MvXr1aNmyJevXr3/p/H379qV58+b0798fZ2dnunXrph6oOnToQLly5XB3d6dt27a8/fbbqR47fvx4oqOjadSoEb6+vqm6+tJTr149nJ2dadiwIadOnWLhwoXp/mKys7Nj4cKFqc6EWrZsGUlJSVhbWzN27FiGDh1KvXr1CAgIoHnz5mmup1GjRkyfPp3BgwcTGBiIh4cH77//Pu+//z7vvPMO9evXT7X8uHHjKFKkCC1atKBnz560a9eOzp07p3oOUVFRqYqMlH+/DGdnZ+Li4tR1vPXWW2pTdlZl9FrmphIlSvD999+zfPly3NzcWLp0Kd9//71aDPXt21f98srKr8nMPufvv/8+pqamNGzYkJEjR2brB1S3bt1o3Lgx3t7edOzYkZYtW77ck86EtbU1P/74I7t376ZRo0a0atVKPaNh5MiRBAQEUKdOHcaNG5fqR1JGj8uITqdj0aJFXLhwAU9PT+rXr8/YsWMz/LHh6upK8eLF1S4jV1dXFEWhWrVqaS5fv3593nrrLRo3bpxuV0Nm5s2bh4eHB1988QUuLi54eXkRGBhIw4YNM/0MZ/Sdl5GMjhvPs7a25vTp03Tt2pW3336bbt26YW9vr541ktIff/zBw4cP1bMinZ2dGT9+PAAzZ84kISGBNm3aUK9ePXx8fNTxL8+7e/cutWrVom3bturzfH5sWlqMlJTttK+wrFxIRwghhBB5Ry7ZKYQQQgiDkCJDCCGEEAZRYLpLhBBCCKEthjtvRbyUpKQkoqKiMDU1zfGpWEIIUVgoikJCQgJWVlYyeaeGSJGhMVFRUanm/xBCCJF19vb2qS5iJ/KXFBka82z6cHt7+xzNqBcYGJjq6pD5RQs5JIO2cmghg1ZyaCGDVnLkNEN8fDyXLl1Sj6FCG6TI0JhnXSRmZmaYm5vnaF05fXxu0UIOyfD/tJBDCxlAGzm0kAG0kSM3Mkg3s7ZIx5UQQgghDEJaMrLp+vXr+Pr68ujRI4oXL46fn98Lc5KMGDGCixcvqn9fvHiR7777Tp3jQwghhCgMpMjIpgkTJtCzZ0+8vb3ZtGkT48ePZ+XKlamWSXmp8QsXLvD++++/9CRMQgghxKtKukuyISwsjHPnzqkTf7Vr145z584RHh6e7mOeTfqWk0GcQgghxKtILsaVDYGBgYwcOTLVFMdt2rThm2++oXr16i8sHx8fj7u7OytWrMDJySlL24iLiyMwMDDXMgshRGFSo0YNTQxiFcmku8SAdu7cSbly5bJcYKSU0w/K8ePHqVu37ks/PrdoIYdk0FYOLWTQSg4tZNBKjpxmkB9o2iTdJdlgZ2dHSEgIer0eAL1eT2hoKHZ2dmku//vvv6eaalsIIYQoTKTIyIZSpUrh5OREQEAAAAEBATg5OVGyZMkXlr137x7Hjx9Xx28IIYQQhY0UGdk0ceJEVq9eTatWrVi9ejWTJk0CYMCAAZw9e1ZdbsOGDTRr1ozixYvnU9LCIzYxNsP7M2uCzezxQgghXo6MycimKlWq4O/v/8LtS5YsSfX34MGD8ypSoWdhYoHRpJe/yp8yQcY+CyGEIUhLhhAiV+W0ZSkr6xBCvBqkJUMIkaty2rIE0rokREEhLRlCCCGEMAgpMoQQooCTwdEiv0h3iRBCFHAyOFrkF2nJEEIUSPLrXYj8Jy0ZQogCSX69a0tsYiwWJhbp3p/Vs44yWofQHikyhChAcnogl4O4MBQ566hwkiJDiAJEfr0LIbRExmQIIYSByIXJRGEnLRlCCGEg0kUgCjtpyRBCCCGEQUiRIYQQQgiDkCJDCCGEEAYhRYYQQgghDEKKDCGEEEIYhBQZQgghhDAIKTKEEEIIYRBSZAghhBDCIKTIEEIIIYRBSJHxipJprIUQQmidXFY8m65fv46vry+PHj2iePHi+Pn5UbFixReW27ZtG4sWLUJRFIyMjFi+fDmlS5fOtRxamAgrKzN2yqyfQghReEmRkU0TJkygZ8+eeHt7s2nTJsaPH8/KlStTLXP27FkWLFjATz/9RJkyZYiIiMDMzCyfEhuOzMsghBAiI9Jdkg1hYWGcO3eOdu3aAdCuXTvOnTtHeHh4quVWrFhB//79KVOmDABFixbF3Nw8z/MKIYQQ+UlaMrIhODgYW1tbdDodADqdDhsbG4KDgylZsqS63NWrVylfvjy9evUiOjqad955h8GDB2NklPVf/YGBgRnen5UpojNz/PjxHD0+NzJoJUdOM2hlG1rYF/K+yN0MWsmhhQy5kUPkLSkyDECv13Px4kWWL19OfHw8H330EeXKlaNDhw5ZXkeNGjUM3vqRWx/6nNJCDkNnOH78uCaeZ1ZoJacWcmghA2gjhxYyQPo54uLiMv1xJvKedJdkg52dHSEhIej1eiC5mAgNDcXOzi7VcuXKlaN169aYmZlhbW2Np6cnZ86cyY/IQgghRL6RIiMbSpUqhZOTEwEBAQAEBATg5OSUqqsEksdq7N+/H0VRSEhI4PDhwzg6OuZHZJFHcnpKcVbWIYQQrxrpLsmmiRMn4uvry8KFCylWrBh+fn4ADBgwAB8fH2rWrEnbtm0JDAykTZs2GBsb07hxY7p06ZLPyYUhyZk2QgjxIikysqlKlSr4+/u/cPuSJUvU/xsbGzNq1ChGjRqVl9GEEEIITZHuEiGEEEIYhBQZQgghhDAIKTKEEEIIYRBSZAghhBDCIKTIEEIIIYRBSJEhhBBCCIOQIkMIIYQQBiFFhhBCCCEMQooMIYQQQhiEFBlCCCGEMAgpMoQQQghhEFJkCCGEEMIgpMgQQgghhEFIkSGEEEIIg5AiQwghhBAGIUWGEEIIIQxCigwhhBBCGIQUGUIIIYQwCCkyhBBCCGEQUmQIIYQQwiCkyBBCCCGEQZjkd4BXzfXr1/H19eXRo0cUL14cPz8/KlasmGqZ+fPn88svv2BjYwNAnTp1mDBhQj6kFUIIIfKPFBnZNGHCBHr27Im3tzebNm1i/PjxrFy58oXlOnTowMiRI/MhoRBCCKENUmRkQ1hYGOfOnWP58uUAtGvXjilTphAeHk7JkiXzOV3hFZMQgzJBydHji5gWycVEQgghQIqMbAkODsbW1hadTgeATqfDxsaG4ODgF4qMrVu3sn//fsqUKcNnn32Gs7NztrYVGBiY4f1169bNXvg0HD9+PEePz40MuZVjxskHL/14X+fSBWpfFIQMWsmhhQxayaGFDLmRQ+QtKTIMoEePHgwaNAhTU1MOHDjAJ598wrZt2yhRokSW11GjRg3Mzc0NmDL3PvQ5pYUcWsgA2siR0ww5bVl6to6CsC9yixZyaCEDpJ8jLi4u0x9nIu9JkZENdnZ2hISEoNfr0el06PV6QkNDsbOzS7VcmTJl1P83atQIOzs7Ll++jKura15HFiLPFTEtkqOWJUhuXRJCvPqkyMiGUqVK4eTkREBAAN7e3gQEBODk5PRCV0lISAi2trYAnD9/nrt371KpUqX8iCyEEDJuSeQbKTKyaeLEifj6+rJw4UKKFSuGn58fAAMGDMDHx4eaNWsye/Zs/vvvP4yNjTE1NWXmzJmpWjeEECIv5bR1SVqWxMuSIiObqlSpgr+//wu3L1myRP3/s8JD5I1EfVKODoKJ+iRMdHJdOiGEyG1SZIhXnonOGIyMXv7xSs4GKQptki4CbcmtAcHymrxapMgQogDRwhdrTluWnq0jp61L0kWgLTIguHCSIkOIAkQLX6w5bVmCgtO6pJVf79KlKPKLFBlCCGEgWvn1Ll2KIr9IaSqEEEIIg5CWDCFEgSRdBNqilbE6Im9JkSFEASJfrP9Pugi0RcbqFE5SZAhRgMgXq7bIr3dR2EmRIYQQBiK/3kVhJ+WxEEIIIQxCigwhhBBCGIR0l7yitHBlR61caEgIIYQ2SZHxitLClR21cqEhIYQQ2iTdJUIIIYQwiELRkhEeHs6mTZvYs2cPFy5cIDIyEmtraxwdHWnSpAkdO3akZMmS+R1TCCGEKFAKfJHx7bffsnnzZjw8POjSpQtVqlTBysqKqKgorl69ytGjR+nYsSNeXl4MHz48v+MKIYQQBUaBLzJsbGz466+/MDMze+G+atWq4eXlRVxcHP7+/vmQ7uVp4cqOcqGh/yeDYIUQ4kUFvsjo06dPpsuYm5vTu3fvPEiTe7RwZUe50ND/k0GwQgjxolf/J2Q2HD58mNu3bwMQGhrKyJEjGTVqFPfv38/nZEIIIUTBU6iKjEmTJqHT6QDw8/MjMTERIyMjxo0bl8/JhBBCiIKnwHeXpBQSEkK5cuVITExk//797Nq1C1NTU9zd3fM7mnjFyfgUIYR4UaE6ollbW/PgwQOOHj2qnmUCkJiYmOV1XL9+ne7du9OqVSu6d+/OjRs30l322rVr1K5dGz8/v5xGFxqnjk/JwT8pMIQQBU2hOqr17t2bLl26MHz4cHr16gXAiRMnqFy5cpbXMWHCBHr27Mmff/5Jz549GT9+fJrL6fV6JkyYQIsWLXIluxBCCPGqMVKUAjK8P4uuX7+OTqfjjTfeUP+Oj4/HwcEh08eGhYXRqlUrjhw5gk6nQ6/X4+bmxo4dO164mNeiRYswMzMjOjqa6OhoRo4cmaV8cXFxBAYGUqNGDczNzTNeOCdnduTWy57Ds0s0kUMLGbSSQwsZtJJDCxm0kkMLGTLJka1jp8gzhaolA6BSpUpqgfHs76wUGADBwcHY2tqqg0d1Oh02NjYEBwenWu7ChQvs37+ffv365VpuIYQQ4lVT4Ad+du7cmY8++ghPT880L8gVHx/Pzp07Wb58ea5ckCshIYFx48Yxffp0tRh5GYGBgRneX7du3Zde9zPHjx/P0eNzI4NWcmghg1ZyaCGDVnJoIYNWcmghQ27kEHmrwHeXXLlyhXnz5nHkyBGqV69OpUqV1MuK37hxg//++4/69evz2WefUaVKlQzXlZXukqCgIDp27KgOKn3y5AmKotCmTRumTJmSaV7pLsmHHFrIoJUcWsiglRxayKCVHFrIkEkO6S7RpgLfkvHWW28xb9487t+/z4EDB7h06RIPHz6kWLFieHt7M3PmTEqVKpWldZUqVQonJycCAgLw9vYmICAAJyenVOMxypUrx5EjR9S/58+fn60xGUIIIURBUeCLjGfKlClDhw4dcryeiRMn4uvry8KFCylWrJh6euqAAQPw8fGhZs2aOd6GEEIIURAU+O6SV410l+RDDi1k0EoOLWTQSg4tZNBKDi1kyCSHdJdoU6E7u0QIIYQQeUOKDCGEEEIYhBQZQgghhDCIQlVkKIrC2rVr6du3L15eXgAcPXqUbdu25XMyIYQQouApVEXG3LlzWbduHd27d1ev0lm2bFmWLl2az8mEEEKIgqdQFRkbNmzg+++/p23bthg9HeVcvnx5bt++nc/JhBBCiIKnUBUZer1evRLnsyIjKioKS0vL/IwlhBBCFEiFqsjw8PBg+vTpxMfHA8ljNObOnUuzZs3yOZkQQghR8BSqImPUqFGEhoZSt25dIiIicHZ2JigoiOHDh+d3NCGEEKLAKTSXFQewtrZm4cKFPHjwgKCgIOzs7ChTpkx+xxJCCCEKpELVkvGMhYUFtra2JCUlERISQkhISH5HEkIIIQqcQtWScfDgQcaNG0dQUBApp2wxMjLi/Pnz+ZhMCCGEKHgKVZExZswYPvnkE9q0aYOFhUV+xxFCCCEKtEJVZMTFxdGpUyd0Ol1+RxFCCCEKvEI1JqNfv34sXboUmd1eCCGEMLxC1ZLRsmVLPvzwQ3744QdKlCiR6r6///47n1IJIYQQBVOhKjJ8fHxwcXGhdevWMiZDCCGEMLBCVWTcuXOHjRs3YmxcqHqJhBBCiHxRqL5tPT09OXz4cH7HEEIIIQqFQtWSER8fz+DBg3FxcaFUqVKp7ps5c2Y+pRJCCCEKpkJVZFStWpWqVavmdwwhhBCiUChURcaQIUNyvI7r16/j6+vLo0ePKF68OH5+flSsWDHVMr///jsrVqzA2NiYpKQkunbtSt++fXO8bSGEEOJVUuCLjKNHj1KvXj0ADh06lO5yDRo0yNL6JkyYQM+ePfH29mbTpk2MHz+elStXplqmVatWdOrUCSMjIyIjI/Hy8sLV1RVHR8eXfyJCCCHEK6bAFxmTJk0iICAASL6seFqMjIyydJ2MsLAwzp07x/LlywFo164dU6ZMITw8nJIlS6rLWVtbq/+PjY0lISEBIyOjnDwNIYQQ4pVT4IuMgIAAAgICaNeuHbt27crRuoKDg7G1tVUvS67T6bCxsSE4ODhVkQHJF/eaPXs2t27d4ssvv8TBwSFH2xZCCCFeNQW+yAAYP3487dq1y9Ntenp64unpSVBQEJ9++ilNmjShcuXKWX58YGBghvfXrVs3pxE5fvx4jh6fGxm0kkMLGbSSQwsZtJJDCxm0kkMLGXIjh8hbRkohmMjD2dmZkydP5ng9YWFhtGrViiNHjqDT6dDr9bi5ubFjx44XWjJSGj9+PBUrVqR///6ZbiMuLo7AwEBq1KiBubl5xgvnpAsmt172nHYDaSGHFjJoJYcWMmglhxYyaCWHFjJkkiNbx06RZwpFS0ZSUhKHDx/OcGK0rAz8LFWqFE5OTgQEBODt7U1AQABOTk4vFBhXr16lSpUqAISHh3PkyBFatmyZsychhBBCvGIKRZERHx/PmDFj0i0ysjrwE2DixIn4+vqycOFCihUrhp+fHwADBgzAx8eHmjVr8ttvv3HgwAFMTExQFIXevXvTuHHjXHs+QgghxKugUHSX1KlThxMnTuR3jCyR7pJ8yKGFDFrJoYUMWsmhhQxayaGFDJnkkO4SbSpUc5cIIYQQIu8UiiKjEDTWCCGEEJpTKIqM3DizRAghhBDZUyiKDCGEEELkPSkyhBBCCGEQUmQIIYQQwiCkyBBCCCGEQUiRIYQQQgiDkCJDCCGEEAYhRYYQQgghDEKKDCGEEEIYhBQZQgghhDAIKTKEEEIIYRBSZAghhBDCIKTIEEIIIYRBSJEhhBBCCIOQIkMIIYQQBiFFhhBCCCEMQooMIYQQQhiEFBlCCCGEMAgpMoQQQghhECb5HeBVc/36dXx9fXn06BHFixfHz8+PihUrplrmu+++Y9u2beh0OkxMTPjiiy9wd3fPn8BCCCFEPpEiI5smTJhAz5498fb2ZtOmTYwfP56VK1emWqZWrVr079+fIkWKcOHCBXr37s3+/fuxsLDIp9RCCCFE3pPukmwICwvj3LlztGvXDoB27dpx7tw5wsPDUy3n7u5OkSJFAHBwcEBRFB49epTXcYUQQoh8JUVGNgQHB2Nra4tOpwNAp9NhY2NDcHBwuo/ZuHEjb7zxBmXLls2rmEIIIYQmSHeJAf3777/MnTuXH3/8MduPDQwMzPD+unXrvmws1fHjx3P0+NzIoJUcWsiglRxayKCVHFrIoJUcWsiQGzlE3jJSFEXJ7xCvirCwMFq1asWRI0fQ6XTo9Xrc3NzYsWMHJUuWTLXsyZMnGTp0KAsXLqR69epZ3kZcXByBgYHUqFEDc3PzjBc2MnqZp5Est172nGTQSg4tZNBKDi1k0EoOLWTQSg4tZMgkR7aOnSLPSHdJNpQqVQonJycCAgIACAgIwMnJ6YUC48yZM3zxxRfMmzcvWwWGEEIIUZBIS0Y2Xb16FV9fX548eUKxYsXw8/OjcuXKDBgwAB8fH2rWrEnnzp25e/cutra26uNmzpyJg4NDpuuXlox8yKGFDFrJoYUMWsmhhQxayaGFDJnkkJYMbZIiQ2OkyMiHHFrIoJUcWsiglRxayKCVHFrIkEkOKTK0SYoMjcnvIiMhIYE7d+4QGxubtfXcvPnyGQDefDNnj8+NHFrIoJUcWsiglRxayKCVHFnMYGFhQfny5TE1NU17ASkyCh05u0SkcufOHYoWLUrFihUxysoBISoqZxt0csrZ43MjhxYyaCWHFjJoJYcWMmglRxYyKIpCWFgYd+7coVKlSi+/LVGgyMBPkUpsbCylSpXKWoEhhBBPGRkZUapUqay3gopCQYoM8QIpMIQQL0OOHeJ50l0iMhcbC+nNu+Li8vLrjYh4+ccKIYTQPCkyROYsLHI+YCstWRhz3Lx5c8zMzDAzMyMmJoa33nqLAQMGUKdOndzP8wo4e/YsK1as4Ntvv82V9X06Zw53QkMBuHDrFvb29hgbG1O6dGlatGhBXFwc/fr1y5VtpSUmLo5eU6aweuxYLC0sUBSFlX/+ydoJE1AUhaSkJFxcXBgxYgTFihXL9vrX793LnpMnmTd0aK7mdnBw4MSJE1hZWeXqel8FQ4cOpW/fvoX2MyiyR4oMoXnz5s3D3t4egB07djBw4ECWLVtG7dq18zlZ1iTq9Zg8ne8mp2rWrJlrBQbAd198of7foVcv1qxZk6dfnKt27KBVvXpYPm0p+5+/P0cvXOCnn36idOnSJCUlsXPnTh4/fvxSRYaApKQkjIyMyK2fCYMGDWLq1KmsXr06l9YoCjIpMsQrpWXLlpw5c4Zly5Yxb9484uPjmTNnDkf37CEhMRH7ChWY2L8/VhYWRERHM231agKvXsXI2BgXBwfG9+tHVGwsU3/6ibPXrgHQvnt3Bg4cCECfPn2oXr06Z86c4e7du/Tt2xdbW1tWr15NaGgoX331Fe+++y6Q/Gt2yJAhHDhwgIcPHzLM25tWrq7J9/XqxVfvvcfeU6eo6+DAR23bMv3nn7l46xZxCQm4VavGqN690Rkbs+D33wk4dAjz117DyMiIlStXYmpqysiRI7ly5QomJiZUqlSJuXPncuTIEfz8/Fi/fj2QPAHfsmXLAHjjjTeYPHkypUj+BR9w8CDFrKy4fOcORS0tmT90KGWKF8/yvp4/fz7R0dGMHDmS9evXExAQQNGiRbl48SK2traMGzeOmTNncvPmTWrUqMGsWbMwMjIiMjKS6UuWpPlcn7d21y5+Gj0agKjYWJZv28bGadMoXbo0AMbGxrRs2RKA+/fvM2zYMKKiooiLi8PDw4MRI0YAqO+Df/75B2NjYypUqMB3330HQGRMDEPnzUtzPyzZsoU///0XfVIStiVKMOWjj9LcRzt27GD27NkUL16cJk2apLrv9OnTzJo1i6inZ2/4+PjQtGlTAHbv3s18Pz8S9XqMjYyYMWgQjm+8wb7Tp5n922/ok5IoWawYk/v3582yZTly7hxfr1pFrcqVOf30tZ+5YAELFizg8uXL2NnZMX/+fCwtLZk/fz5XrlwhOjqaoKAgKleuzLRp0yhatCjz58/n5s2bREdHc/v2bVavXs2pU6dYtHEj8QkJmJqYMKp3b96uWpVrQUGM+uEHYuLjSUpKomOTJnzYti07jx1jrr8/xsbG6M3NGTduHG5ubjg6OhIWFsaNGzeoWLFilt9PonCSIkO8cmrXrs2uXbsAWLp0KUWLFmXdlCkAfPPrryzevJkvunVj2qpVWFpYsGn6dIyNjQl/OgZk4YYNJCkKW2bMIComhu5+fjg4OODh4QHAvXv3WL16Nffv36dly5b069ePNWvWcObMGYYMGaIWGZA80G3NmjVcu3aN97p2xcXBgVKvvQZAkqKwauxYAMYsWUI9R0e+HjCApKQkhi9cyO979tDKzY1l27ZxaNEiLBo2JDIyEgsLC3bv3s2TJ0/Ytm0bAI8fP35hP1y6dIlZs2axfv16bGxs+N///seUKVP4X+/eAJy9do3NM2ZgV6oUY5csYfWOHXzRrdtL7/ezZ8+yZcsWypYty8cff8yXX37J6tWrKVKkCB07duTQoUM0bNiQ6dOnp/lcuzVvnmp9wWFhxMTF8XqZMgBcvXsXM1NTKpcrl+b2ixUrxvfff4+VlRUJCQl8+OGH7Nu3jyZNmrB48WJu377N+vXrMTMzIzw8/P9zp7MfNu3fz62QENZOmoSxsTG/7NzJjJ9/5ttPP0213bCwMMaNG8evv/5K5cqVWbJkiXrfkydPmDBhAosXL8bGxobQ0FC6dOlCQEAAYWFhjB07lp9HjaJi2bLEJyQQn5hI2OPHjFi0iNVjx/JW+fL479nD8IUL8Z88Wd0Pfh9/zNQBA5i0fDkffvgha9eupWzZsgwYMICtW7fStWtXIHmysI0bN1K6dGlGjRrFwoULGTlyJADHjh1j/fr1lCxZklu3brFwwwaWjRyJtaUll+/cYcDMmeyZN49fdu6kydtv82nHjgA8floszfv9dyZ88AEujo7onZ2JiYlRn/fbb7/NoUOHpMgQmZIiQ7xyUl4/bteuXURGRvLnhg0AxCcm4vjGGwDsPnmS9VOnYvz0F3TJokUBOBQYyOi+fTEyMsLa0pK2bdty6NAhtcho3bo1xsbG2NraUrx4cVq0aAFA9erVCQkJIS4uTr3Yz7ODfeXKlalWsSKnrlzB8+lskx3d3f8/54kTnLl6leVPi4bY+HhsS5bEukgRKtnZ8dXChbjfuUPTpk2xtrbG0dGRa9euMWnSJFxdXdVfxikdOXIEDw8PbGxsAOjRowfe3t7wtMioY2+PXalSANSuWpWDZ8/maL/XqVOHsmXLAuDk5MTrr79O0af71NHRkZs3b9KwYUN27drFGSurF57r8+6Fh6sFGaR+XdOi1+uZOXMmJ0+eRFEUHjx4wIULF2jSpAm7d+/G19cXMzMzgFTzCaW3H3adOEHgtWt0HDMmef1JSVgXKfLCdk+dOkW1atWoXLkyAN27d2fWrFlA8kSId+7cYcCAAeryRkZG3Lx5kzNnztCkSRMqPt1nZqammJma8u/58zi+8QZvlS8PQOcmTZi0fDmRT7/EK9nZ4fT0y7tapUoEJSaq+7169ercTHFRraZNm6qtPl26dGHq1KnqfU2aNFH3wz///MOt0FB6PS3GIbkb78Hjx9RzdMTvl19ISEzErVo16lerBkD9atWY8fPPtHZzo0mxYmqXJUCZMmW4d+9ehq+XECBFhngFnT17lqpVqwLJX0wTJkygQXpXGEyDAi/0T6c89S7l1QJ1Op36t+7puIrExMQ0ryioKEqq9VimOCNHURQWDhtGhacFQUprJ03ixKVLHL53j06dOrF06VIcHR3Ztm0bhw8fZt++fcyZM4ctW7ZkuL3nmafYJzojI/R6fbrLZkV6++XZ38/Wn9FzTcnC1JS4hAT177fKlycuIYHrwcGkdSmn5cuX8+TJE/z9/TF/2nwfFxenbjPd3OnsB0VRGNyhA13SKOBSymjdiqLg4ODAzz///MJ9p0+fTvcxGb1uZs/lfX4/P3vOma33+bE17rVqMXPw4Bce18rVlberVuXAmTMs2byZ3/fuZdYnnzC6Tx8u3rrF4XPn+Pzzz/nggw/o9rQlLC4ujuLZ6HoThZdcJ0O8Unbu3Mmvv/7KBx98ACSffbJixQpi4+OB5P73q3fvAtDM2ZllW7eqXxLPuksa1qjBuj17UBSFyJgYtm3bRoMGDV4qz++//w7AjRs3OH/zJrWrVElzueZ16rB482b0SUlqltuhoUTGxBD+5AmuTk74+Phgb2/P5cuXuXfvHjqdjhYtWjBq1CjCw8N59OhRqnU2aNCAvXv3cv/+fQDWrl1Lw4YNX+p55KbmzZun+VyfV6lcOe4/fEj800LDysKCfq1bM37ZMsLCwoDkL87Nmzdz69YtIiIiKFOmDObm5oSEhPD333+n2uZPP/1E/NP3QcruknRz1qnDLzt3qt0D8QkJXEjj0tvOzs6cO3eOGzduAODv75/qvps3b3L48GH1tjNnzqAoCo0bN2bfvn3cePqLPz4hgciYGJyrVuX8zZtcDQoCYMM//1DtzTfTbEXJzJ49e9TnumHDBtzc3NJcrlGjRvxz5gyX79z5/5xXrwJw8949yrz2Gp08PPi0UyfOPr39WlAQDm+8wfutW9O+fXvOpmgJu3r1Ko6OjtnOKwofackQmYuNzb0JklKKiICnze0Z8fHxUU9hrVKlCosXL+btt98GYODAgSxYsIAu48Ylj6A3MmJIp05Uef11RvXuzbRVq2g3ciQ6nQ5XR0fGvv8+n3TsyJQVK/Dy9QWSB34+P5gvq8zMzOjRowcPHz5k8ocfpmr+T2l0nz588+uveI8ahRFgamrK6D59MNXp+GzuXGLj41EsLKhWrRotW7bk8OHD6lkkSUlJDBw4EFtbW/WLDqBq1ap8+eWX9O/fH4AKFSowefJkSLFMfhg9ejTfjBjxwnN9vmXDwswMt2rVOHL+PO61agEwrHt3VvzxB3369AGSiwwXFxeaNm1Knz59+Pzzz+nQoQNly5ZNVRgOHDiQb7/9lg4dOmBqasqbb77JvHnzMszZwd2dR5GR9H7ahaAoCu+1aIHjc/N0lCpViilTpjBo0CCKFy9O69at1ftee+01Fi5cyDfffMO0adNISEigQoUKfP/991SsWJEpU6bwhZ8f+qQkdMbGzPj4YxzeeIOZgwcz/LvvSNTrKVmsGN988slL7esGDRowevRobt++TaVKlfB9+p5+XsWKFflm8GDGLF5MbEICCYmJ1LG3p1aVKvxx5AhbDhzA1MQEIyMjRj/d99/+9hs3791DZ2xMsbJl+frrrwGIjo7mypUr1K9f/6Uyi8JFJkjTmPyeIO38+fM4ZWeuhGPHXj4D5OxiXrmV4yUzvHCthEK8L142w4lLl1gaEMDCYcPyNUeatJAhgxwpz/4xeI4UGdasWcO9e/cYms61RzI8hsgEaYWOdJcIIfJNHXt7mjk7Ey3zXbwydDqdesq3EJmR7hIhXtLFixfzO0KB0LVZs/yO8Er67LPP8mW7z86oEiIrpCVDCCGEEAYhRYYQQgghDEKKDCGEEEIYhBQZQgghhDAIGfgpMpWYpGBinM6pZzk4zS8xLj7TN6BM9Z5aQZ/qvc/UqQQ9eIB1qVLExcXx3nvv8f7772e4jp07d2JjY0Otp9fauHTpEt98802qOUaEEPlDigyRKRNjI2acfJDr6/V1Lp2l5WSq9/9X0Kd6Bxjbty/NBg4kODiYdu3aqTN/pmfnzp3UqFFDLTLs7e0xNTXl8OHD1DeRQ5wQ+Uk+gdl0/fp1fH19efToEcWLF8fPz++FmQj379/P7NmzuXTpEn369Mn6xXJEpmSq94I71fvz7OzsqFSpEtevX2fFihXUqFGD3k8nf/P19aVGjRq8+eab7Nq1i4MHD+Lv788HH3xAhw4daNeuHf7+/tR/770sP18hRO6TIiObJkyYQM+ePfH29mbTpk2MHz+elStXplqmQoUKTJ06lT///FOdS0HkHpnqPVlBm+r9eVeuXOHatWs4ODiwd+/eNJdxd3enefPmqQoQSJ6K/OuvvwYpMoTIV1JkZENYWBjnzp1j+fLlALRr144pU6YQHh6eamrpN5/OffD3339LkWEAMtV7soI21fszU1eu5H9bt2Jubs7kyZPVKdazo3Tp0jx48ICExERMpctEiHwjn75sCA4OxtbWVp3yW6fTYWNjQ3BwcKoiIzcEBgZmeH/dp19kOXH8+PEXbjMxMSHq6ayUzxi6j/757aWUlJRETExMqmVOnDhB5cqViYqKQq/X58pU74mJier6FEVRt2dkZERSUlKq7T958gRLS0sgebKoqKgorKyscmWq944dO7JgwQLs7e1Zt24d//77L/v27ePbb79l7dq1xMbGqnni4uLQ6/Vqtujo6FTrfdmp3p+tLz4+noSEBHVbOp1OvU+v12NsbKz+rSiKui9edqr3Z56NyXi27mfrjI2NTXVbXFwcUVFRJCYmqv9/JjIyElNT0xwXGBm9N7Mitz47WsiR1Qzx8fFpHlty45gFaR+3hHZJkaFReTHJT1of+vPnz+fpwD/I+ABobGxMkSJF1GV27tzJunXrWLp0KVZWVrRo0YIVK1bg/P77WJiZERkTQ0h4OFVef12d6n3s01aL8IgIShYtqk71XsfenqjYWLZt28aIESOwsrJCp9NhYWGhbu/57QNYWlqqf//xxx988sknWZ7qfWL//uiedt1ExcRQomhRomNjcXVywtXFhVOnTnHnzh3s7Ox47bXXaNeuHZ6enri7u5OQkICFhQXGxsZYWVnh4eHBTz/9RHR0NGXKlCEgICBXpnp/9tzMzMxITEzEysoKc3NzTExM0rwPkotTc3NzrKys1Knen3+uzxcdKad6N0ujSEy5zytXrszFixexsrIiNDSU48eP4+bmhpWVFcWLFyc+Pj7V8leuXFEHC+fGvshvWsiR1QxmZmYGHZSdXrHybII0oS1SZGSDnZ0dISEh6PV6dDoder2e0NBQ7Ozs8jtagSZTvReeqd7T061bN3x8fGjfvj0VK1ZUzyQBaN++PaNGjWL79u3qwM9//vmHVq1aGeLpCSGyQaZ6z6Y+ffrQpUsXdeDnunXrWLVqVZrLZnsqZrQ51XuG18nIgcS4eEzMzXJnZTLV+/97haY3N8RU7/Hx8XTt2pXly5dT8ukZRC9FC6+HVnJkI4NM9S5SkpaMbJo4cSK+vr4sXLiQYsWK4efnB8CAAQPw8fGhZs2aHDt2jGHDhhEZGYmiKGzdupWvv/4a9xQDAV8lGRYYOThwmUDuHUDFKynlVO8px7DkRFBQEMOGDUseJ5WTIkMIkWNSZGRTlSpV8Pf3f+H2lFcXdHFxYd++fXkZS+QDmeo9d+T2VO8VK1Z84do1Qoj8IXOXCCGEEMIgpMgQQgghhEFIkSGEEEIIg5AiQwghhBAGIQM/RaZiE2OxMEln5H8Ozg6JjYkgd84nEEIIoUVSZIhMWZhYYDQp96+ToUzI/BItzZs3x8zMTL0Y11tvvcWAAQOoU6dOrud5FZw9e5YVK1bk2nTvn86Zw53QUAAu3LqFvb09xsbGlC5dmhYtWhAXF0e/fv1yZVtpiYmLo9eUKaweOxZLCwv6TJ1K0IMHWD+dcwWSJyXM6PX++++/OXbsWIbXo3kSFcVvu3YxwMtLvW3MkiV0dHfHJYNp5F9GeHg4gwYN4pdffsFE5k0RhZx8AoTmzZs3T71E9I4dOxg4cCDLli0z6KWLc1OiXo/J0/lucqpmzZq5VmAAfPfFF+r/HXr1Ys2aNXl6CetVO3bQql69VNfIeDZ3SVZ5enri6emZ4TJPoqNZGhCQqsj4esCA7AfOgpIlS1K7dm02bdpE586dDbINIV4VUmSIV0rLli05c+YMy5YtY968ecTHxzNnzhyO7tlDQmIi9hUqMLF/f6wsLIiIjmba6tUEXr2KkbExLg4OjO/Xj6jYWKb+9BNnn16oqX337gx8+qXWp08fqlevzpkzZ7h79y59+/bF1taW1atXExoayldffaVO9e7g4MCQIUM4cOAADx8+ZJi3N61cXZPv69WLr957j72nTlHXwYGP2rZl+s8/c/HWLeISEnCrVo1RvXujMzZmwe+/E3DoEOavvYaRkRErV67E1NSUkSNHcuXKFUxMTKhUqRJz587lyJEj+Pn5sX79egA2btzIsmXLAHjjjTeYPHkypYD1e/cScPAgxaysuHznDkUtLZk/dChlihfP8r5OecXa9evXExAQQNGiRbl48SK2traMGzeOmTNncvPmTWrUqMGsWbMwMjIiMjKS6UuWpPlcn7d21y5+Gj060ywbN27kr7/+4rvvvgOSJ7Rr2rQpa9as4d9//2XPnj3MmzcPgHXr1rFy5UoATBMS+GH4cCavWEFEdDTeo0ZRxNycNRMn0mfqVPq3aUOzOnV48PgxE378kVshIaAofNiuHR2edgU2b94cb29vDh48yP379+nfvz+9e/cmKSmJyZMnc/jwYczMzLC0tGTNmjVA8gzN06dPlyJDFHpSZIhXTu3atdm1axcAS5cupWjRoqybMgWAb379lcWbN/NFt25MW7UKSwsLNk2fjvHTiboAFm7YQJKisGXGDKJiYuju54eDg4M61fu9e/dYvXo19+/fp2XLlvTr1481a9Zw5swZhgwZohYZkDxL65o1a7h27Rrvde2Ki4ODOn9JkqKwauxYILlpvp6jI18PGEBSUhLDFy7k9z17aOXmxrJt2zi0aBEWDRsSGRmJhYUFu3fv5smTJ2x7Ol3648ePX9gPly5dYtasWaxfvx4bGxv+97//MWXKFP73dKr3s9eusXnGDOxKlWLskiWs3rGDL7p1e+n9fvbsWbZs2ULZsmX5+OOP+fLLL1m9ejVFihShY8eOHDp0iIYNGzJ9+vQ0n2u35s1TrS84LIyYuDheL1Mm1e3Ppnp/5scff6RVq1ZMnz6d8PBwSpYsyb59+6hcuTLly5fn33//VZc9cuQIP/zwA7/88gtlypQhav9+TIyNGd+vH53HjmXT9OlpPrepP/1E1fLl+e6LLwh9+JBOY8dSrW1btQUtNjaW3377jTt37uDl5UXHjh25efMmhw4d4o8//sDY2DjVa1S9enUuXLhAdHQ0li+9x4V49UmRIV45Kafb2bVrF5GRkfy5YQMA8YmJOL7xBgC7T55k/dSpGD/9BV2yaFEADgUGMvrpzKzWlpa0bduWQ4cOqUVG69atMTY2xtbWluLFi9OiRQsg+YsjJCSEuLg4dW6Erl27AsmzhFarWJFTV67g+XSWyI4pLiO/68QJzly9yvKnRUNsfDy2JUtiXaQIlezs+GrhQtzv3KFp06ZYW1vj6OjItWvXmDRpEq6urjRt2vSF/XDkyBE8PDyweTrxWI8ePfD29oanRUYde3vsno5tqF21KgfPns3Rfq9Tpw5ly5YFwMnJiddff52iT/epo6MjN2/epGHDhuzatYszVlYvPNfn3QsPT3NCufS6Szw9PQkICKBv375s2LCBTp06vbDMnj178Pb2pszTwsUqi5cqP/Tff/j26gWATYkSeLz9NkeOHFGLjDZt2gBQvnx5ihUrxr1796hQoQJ6vZ4xY8bg5uZGsxRXLjUxMcHa2pr79+/zZpYSCFEwSZEhXjlnz56latWqQHLBMWHCBBqkMVV4ehTg+WGsRikmbko5uZJOp1P/1j0dV5GYmJjmBEyKoqRaT8pxBoqisHDYsBdmIgVYO2kSJy5d4vC9e3Tq1ImlS5fi6OjItm3bOHz4MPv27WPOnDls2bIlw+09zzzFPtEZGaHX69NdNivS2y/P/n62/oyea0oWpqbEJSRkefudOnVi2rRpeHl58e+//zJz5sxsPoOMPb8vM3pP6PV6ihYtytatWzly5AiHDh1i1qxZbNiwQS1w4uPjscil+ViEeFXJdTLEK2Xnzp38+uuvfPDBB0Byf/mKFSuIjY8HIDImhqt37wLQzNmZZVu3qi0fz7pLGtaowbo9e1AUhciYGLZt20aDBg1eKs/vv/8OwI0bNzh/8ya1q1RJc7nmdeqwePNm9ElJapbboaFExsQQ/uQJrk5O+Pj4YG9vz+XLl7l37x46nY4WLVowatQowsPDefToUap1NmjQgL1793L//n0A1q5dS8OGDV/qeeSm5s2bp/lcn1epXDnuP3xIfBYLDRcXFyIjI5k9ezYtWrSgSJEiLyzTrFkzNm3axIMHDwCIio0lPiEB6yJFiI2PJzGdQqtB9er89rQL7v6jR+w9dQo3N7cM84SHhxMbG0uTJk0YPnw4RYsW5fbt2wA8ePAAnU6ntjIJUVhJS4bIVGxibJZON832emMisChSNNPlfHx81FNYq1SpwuLFi3n77bcBGDhwIAsWLKDLuHEYGRlhZGTEkE6dqPL664zq3Ztpq1bRbuRIdDodro6OjH3/fT7p2JEpK1bg5esLJA/8bNKkyUs9BzMzM3r06MHDhw+Z/OGHaTb/A4zu04dvfv0V71GjMAJMTU0Z3acPpjodn82dS2x8PIqFBdWqVaNly5YcPnxYPYskKSmJgQMHYmtry40bN9R1Vq1alS+//JL+/fsDUKFCBSZPngwplskPo0eP5psRI154rs+3bFiYmeFWrRpHzp/HvVYt9fbnx2T4+PioZ4906NCBuXPn8vPPP6e5bVdXVwYOHMgHH3yAkZERZgkJfD98OKVfew2vhg3x8vXlNSsr1kycmOpxY99/n/HLliW/JxSF4T16qK1l6QkODmbcuHEkJiai1+tp0qSJ+r7cv38/77zzToYtTUIUBkZKyg5uke/i4uIIDAykRo0aaTbJp5KTA1g6L/v58+dxcnLK+npyMNU7kHtTveckx0tmcHBw4MSJE/9/ymch3hcvm+HEpUssDQhg4bBh+ZojTTnI0Lt3byZNmkSVKlUK3fsiw2NITouuDL6usnXsFHlGukuEEPmmjr09zZydiY6Nze8ouSY8PJzu3bsnFxhCFHLSXSLES7p48WJ+RygQuqY4K6MgKFmyJF4pLvolRGEmLRniBdKDJoR4GXLsEM+TIkOkYmFhQVhYmBwshBDZoigKYWFhctquSEW6S0Qq5cuX586dO+ppkZl6eqrgSzt/PmePz40cWsiglRxayKCVHFrIoJUcWcxgYWFB+fLlX347osCRs0s0Jr/PLsk2A44Wz7McWsiglRxayKCVHFrIoJUcWsiQSQ45u0SbpLtECCGEEAYhRUY2Xb9+ne7du9OqVSu6d++e6uJIz+j1eiZNmkSLFi1455138Pf3z/ugQgghRD6TIiObJkyYQM+ePfnzzz/p2bMn48ePf2GZLVu2cOvWLXbs2MFvv/3G/PnzuXPnTj6kFUIIIfKPDPzMhrCwMM6dO8fy5csBaNeuHVOmTFGnn35m27ZtdO3aFWNjY0qWLEmLFi3Yvn07H330UabbeDZEJv7pXBwZsrN7uScCEBf38o/NrQxayaGFDFrJoYUMWsmhhQxayaGFDJnkeHbMlGGG2iIDP7MhMDCQkSNHsjXFvApt2rThm2++oXr16uptXl5efP3119R6Oh/DkiVLCAkJYezYsZluIyIigkuXLuV+eCGEKATs7e0pWjTzOZFE3pCWDI2xsrLC3t4eU1NTmVxJCCGySFEUEhIS/n8uIaEJUmRkg52dHSEhIej1enQ6HXq9ntDQUOyeawK0s7MjKChIbckIDg6mXLlyWdqGsbGxVOFCCPES5EJg2iMDP7OhVKlSODk5ERAQAEBAQABOTk6pxmMAtG7dGn9/f5KSkggPD2fnzp20atUqPyILIYQQ+UbGZGTT1atX8fX15cmTJxQrVgw/Pz8qV67MgAED8PHxoWbNmuj1eiZPnsyBAwcAGDBgAN27d8/n5EIIIUTekiJDCCGEEAYh3SVCCCGEMAgpMoQQQghhEFJkCCGEEMIgpMgQQgghhEFIkSGEEEIIg5AiQwghhBAGIUWGEEIIIQxCiowC7tkFwfJCfHw8ISEhL9x++fLlPMsAcOnSJXWbN27cYMWKFRw8eDBPMzxv/Pjx+bp9gMePH3Ps2DHCwsLybJvh4eGpZhTetGkTU6dOxd/fP88yAOzevZuEhIQ83ebzkpKS2L59OydPngRgx44dTJkyhTVr1pCUlJSnWUJCQlixYgVff/01fn5+rFu3jrjcmmk1h/LymCUMTy7GVcA1bdqUPXv2GHw7+/fv54svvgCgQoUKzJkzhzfffBOAjh07smHDBoNnAFi1ahXLly8nMTGRDz/8kE2bNlGzZk2OHDlCnz596NWrl8EzzJw584Xb/P396dq1KwAjRowweAaAKVOmMG7cOABOnTrFJ598QtmyZQkKCuKbb77B3d3d4Bnat2/PL7/8grW1NYsWLWLfvn14enpy6NAh7O3tGTlypMEzADg5OfHaa6/h5eVF586dcXR0zJPtpjR58mQCAwNJTEykcePG/Pvvv+q+qFy5cpZmac4NmzdvZs6cOTg6OnLy5EkaNGhAVFQUly9f5vvvv8fBwSFPcqQnr45ZIm/IBGkFQFpfapA8K2FERESeZJgzZw6rVq3C0dGRDRs28MEHH7Bw4UIcHR3JyzrW39+fgIAAoqOj8fT05M8//6Rs2bKEh4fTv3//PCkyfvnlF1q0aEHFihVT3W5paWnwbad04sQJ9f/z589n1qxZNGzYkPPnzzN+/Pg8KTIURcHa2hqAv/76i1WrVmFlZcX7779Pp06d8qzIcHBwYMaMGaxbt45+/fpRrlw5OnfujJeXF8WKFcuTDIcPH2bLli3Exsbi7u7Ovn37sLa2VvdFXvnhhx/4/fffKVmyJLdv32batGksXryYQ4cOMXnyZH7++WeDZ9DCMUvkDekuKQBWrVqFubk5lpaWqf5ZWVnl2XTxer1e/XXYsWNHZsyYweDBgzlz5kyeTllvbGyMpaUlpUuXpkKFCpQtWxaAkiVL5lmO9evXExISgpWVFZ9++ilDhgyhaNGiDBkyhCFDhuRJhuc9ePCAhg0bAsm/6lN2YRhaeHg4kFxkmZubA2Bqaoper8+zDEZGRjg6OjJ27Fj++ecfPvroI3bv3o2HhwdffvllnmQwMTFBp9NhaWlJkSJF1OLLzMwMY+O8OxTrdDp1UscKFSoQHBwMQIMGDXj48GGeZNDCMUvkDWnJKADs7e1p1apVmk3AedX3nZiYSFxcnPol4urqyuzZs/n888/ztK83Zd/2sGHDUt2XV33ylStX5qeffmLx4sX07duXiRMn5suBMyQkhJkzZ6IoCo8fP0av16PT6QDybAzA4MGD6du3L/3798fFxQUfHx9atWrFgQMHaNKkSZ5kAFK1ppmamtKmTRvatGnDvXv32LhxY55ksLOzY+bMmURFRVGlShWmTZuGl5cX//zzD6VLl86TDADly5dn0aJFuLu7s3XrVqpWrQok/1DIq8JPC8cskTekJaMAGDZsGFZWVmneN3v27DzJ0KZNG44dO5bqNmdnZ+bOnUu5cuXyJANAv379iIqKAqB58+bq7deuXaNRo0Z5lsPY2JhBgwYxZswYRo0aRXR0dJ5t+5mePXuqvw67dOnCo0ePgOTio3r16nmSoU2bNkyfPp2DBw+yd+9ebt++zR9//EGTJk3yrKsESHecQdmyZRk0aFCeZJg+fTqJiYlYWFgwf/58KleuzOjRozl79iyTJk3KkwyQPDbkypUr+Pr6Eh4ezqhRowCIiIhgzJgxeZJBC8cskTdk4KcQBpaYmMj9+/exs7PL7yhCCJGnpLukgAgKCmL79u1q/6qdnR0tW7akfPnyhSqDVnJoIYNWcmghg1ZypJWhVatWvP7663mWIb0cWtgX+fG+EIYl3SUFgL+/P++99x53797F1tYWW1tb7t69S+/evfOsf1MLGbSSQwsZtJJDCxm0kiO9DL169ZJ9kU/vC5EHFPHKa9mypRIWFvbC7WFhYco777xTaDJoJYcWMmglhxYyaCWHFjJoJYcWMoi8IS0ZBUBSUpJ6SlpKJUqUyLNrVGghg1ZyaCGDVnJoIYNWcmghg1ZyaCGDyBsyJqMAaNy4MR999BHdunVTz+QICgpi7dq1eXZGhRYyaCWHFjJoJYcWMmglhxYyaCWHFjKIvCFnlxQASUlJbN68mT/++IOgoCAAypUrR+vWrfH29s6TC/1oIYNWcmghg1ZyaCGDVnJoIYNWcmghg8gbUmQIIYQQwiCku6SA0MLpYFrIoJUcWsiglRxayKCVHFrIoKUcafnvv//y7GJxwvCkTaoA0MLpYFrIoJUcWsiglRxayKCVHFrIoKUc6Zk7d25+RxC5KT9OaRG5Swung2khg1ZyaCGDVnJoIYNWcmghg5ZyKIqihIeHK+fOnVPOnTunhIeH5+m2Rd6Q7pICQAung2khg1ZyaCGDVnJoIYNWcmghg1Zy3Lp1i3HjxnHu3DlsbGwACA0NpVq1akyePJk333wzT3IIw5MiowDQwulgWsiglRxayKCVHFrIoJUcWsiglRwjRoygZ8+eLF++XD2TJCkpiS1btjBixAh+++23PMkhDE/OLikAtHA6mBYyaCWHFjJoJYcWMmglhxYyaCVH69at2b59e7bvE68eKTKEEELkqR49etC7d2/atm2LkZERAIqisGXLFlavXs3atWvzOaHILXJ2SQH333//5XcETWQAbeTQQgbQRg4tZABt5NBCBsi7HDNmzMDf3x83Nze8vLzw8vLCzc2NdevWMWPGjDzJIPKGFBkFnBZOB9NCBtBGDi1kAG3k0EIG0EYOLWSAvMtRsWJFfvrpJ7Zv386MGTOYMWMG27dvZ+XKlVSuXDlPMoi8Id0lBcjDhw+5d+8eAGXLlqVEiRKFMoNWcmghg1ZyaCGDVnJoIYOWcoiCTc4uKQC0cDqYFjJoJYcWMmglhxYyaCWHFjJoKYcoJPL+0hwit3Xv3l3ZtGmTotfr1dv0er2yceNGpVu3boUmg1ZyaCGDVnJoIYNWcmghg5ZyiMJBxmQUAI8ePaJ9+/apTj0zNjbG29ubx48fF5oMWsmhhQxayaGFDFrJoYUMWsohCgcpMgqA4sWLExAQkOpqfYqisHnzZooVK1ZoMmglhxYyaCWHFjJoJYcWMmgphygcZOBnAXDjxg0mTJjA+fPnsbW1BSAkJARHR0cmTpyYJ6O1tZBBKzm0kEErObSQQSs5tJBBSzlE4SBFRgESHh6eaurmtOYnKAwZtJJDCxm0kkMLGbSSQwsZtJRDFGxSZAghhBDCIGRMhhBCCCEMQooMIYQQQhiEFBlCFBBt27blyJEj+R1DCCFUcsVPIV4Rzs7O6v9jYmIwMzNDp9MBMGnSJLZu3ZonOZ48ecL06dPZt28f0dHR2NjY0LlzZwYOHAiAg4MDO3bskCtHCiGkyBDiVXHy5En1/82bN2fq1Kk0bNgwz3NMnz6d6Ohotm3bRtGiRbl+/TqXL1/O8xxCCO2T7hIhCojmzZtz8OBBAObPn4+Pjw/Dhw/H2dkZLy8vrl+/zg8//ECDBg3w8PBg//796mMjIiIYPXo0jRs3xt3dnTlz5qDX69PcztmzZ/Hy8uK1117D2NiYKlWq0Lp1awB69eoFgLe3N87Ozmzbtg2A3bt34+3tjYuLCz169ODChQupcv/www+0adOGevXqMWrUKOLi4oDk0yw//vhjXFxccHV1pWfPniQlJeX+zhNCGIQUGUIUUM++2I8ePYqTkxMffvghSUlJ7Nu3j08//ZTx48ery44cORITExN27NjBxo0bOXDgAP7+/mmut3bt2syZM4fff/+dGzdupLrv559/BmDTpk2cPHmSNm3a8N9//zF69GgmT57MkSNH6N69O5988gnx8fHq47Zs2cKyZcv466+/uH79OgsXLgRg+fLl2NracujQIQ4cOMCwYcMwMjLK5T0lhDAUKTKEKKBcXFxwd3fHxMSE1q1b8/DhQwYOHIipqSlt2rTh7t27PHnyhAcPHrBv3z5Gjx6NpaUlpUqVol+/fumO8Rg3bhxeXl78/PPPtG3blnfeeYe9e/emm2Pt2rV0796d2rVro9Pp6NixI6amppw6dUpdplevXtjZ2VG8eHEGDx6sbtvExIT79+8TFBSEqakpLi4uUmQI8QqRMRlCFFClSpVS/29hYUGJEiXUgaIWFhYAREdHExoaSmJiIo0bN1aXT0pKws7OLs31WlhYMGjQIAYNGkRkZCSLFy9m6NCh7N69m+LFi7+wfFBQEBs3bmT16tXqbQkJCYSGhqp/p9xWuXLl1Ps+/PBDFixYQP/+/QHo3r27OsBUCKF9UmQIUciVLVsWMzMzDh8+jIlJ9g4J1tbWfPzxx/zwww/cuXMnzSLDzs6OQYMGMXjw4HTX8+zy1pBclNjY2Kjr9/X1xdfXl8uXL9O3b19q1qxJgwYNspVTCJE/pLtEiELOxsaGRo0aMWPGDCIjI0lKSuLWrVv8+++/aS7/3XffcebMGeLj44mLi2PlypUUK1aMSpUqAVC6dGlu376tLt+1a1fWrFnD6dOnURSF6Oho9uzZQ2RkpLrML7/8wr1793j06JE6CBSSx5XcvHkTRVGwtrZGp9OlmqJcCKFt0pIhhGDmzJnMmjWLNm3aEBUVRYUKFRgwYECayxoZGTF69GiCgoIwMTHBwcGBH374ASsrKwCGDBmCr68vsbGxTJ48mTZt2jBlyhQmT57MzZs3sbCwoE6dOri4uKjrbNeuHf379yc0NBRPT0+11ePmzZtMmTKF8PBwihUrxnvvvYebm5vhd4gQIlfIBGlCiHyVn9f8EEIYlrQ7CiGEEMIgpMgQQgghhEFId4kQQgghDEJaMoQQQghhEFJkCCGEEMIgpMgQQgghhEFIkSGEEEIIg5AiQwghhBAG8X8wCORHCy55JAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhkAAAExCAYAAADRDbBNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABbh0lEQVR4nO3deXwM9x/H8VeySUSEOhNRt8rhDpEQIm5KIm7qrpbSaqpoxV1HEZSijVbrRxVVcQtVbV1107pS1H0mEhJH7nN+f2CakFt2M5LP8/HweMjO7Mx7ZndnPzvf78zXSFEUBSGEEEKIXGac1wGEEEIIkT9JkSGEEEIIvZAiQwghhBB6IUWGEEIIIfRCigwhhBBC6IUUGUIIIYTQCykycsmJEydo166dQdcZFBSEo6MjSUlJBl2vIdy+fRs7OzsSExP1vq6NGzfy1ltv6X09WXH06FGaNWuW5fnt7Oy4ceOGHhO9PEO+lvr222+/4e7ujqOjI+fOnTPYejPbhx07duTo0aMGy5ORxYsXM2bMGIOu891332XTpk3pTvfx8WHBggUGTJS2/v374+/vr/f1bN26lcGDB+t9PVlhktkMLVu25P79++h0OnQ6HW+88QZeXl706tULY2OpUZ5xcnLi119/zdVlnjhxgiFDhgCgKAoxMTFYWFio07dv387JkydzdZ0Z2bNnD19//TWXL1+mUKFCNG3alE8++YSyZcsaLIOh3b59m1atWqn7vXDhwrRt25YJEyZgamqax+lEburfvz+dOnWiR48e6c7j6+vLpEmTaN26tQGTZW779u15HSFPff/99+r/N27ciL+/Pz/99FOOlxcfH8+3337Ltm3bCA0NpWTJkri4uPDBBx9Qvnz53Ij80k6cOMG8efO4dOkSOp2OqlWrMn78eOrUqUOnTp3o1KlTrq5PURS+/PJLNm7cSHR0NDVq1GDy5MlUr149w+dlqUr45ptvOHnyJHv27GHIkCF89913TJgwIVeC54VX5ReVk5MTJ0+e5OTJkwQEBABw/Phx9bFy5coZLMvOnTsZPXo0AwYM4MiRIwQEBGBmZkafPn149OhRrq5Li6/Ps/2+bds2Tp06xerVq9OcT4vZRe4JCgrK9KAqXn3e3t7s3r2befPmceLECbZs2UKtWrU4fPhwXkcDIDIykmHDhtGvXz+OHTvG/v37GTFiBGZmZnpb5y+//MKGDRtYs2YNx44do169enz66aeZPi9bpyKKFi1Kq1at+PLLL9m0aRMXL14EnlR9vr6+NG/eHFdXVyZPnkxsbKz6vN9//x0vLy/q169P69at2b9/PwAhISEMGzYMZ2dn2rRpw7p169TnLF68GG9vb8aMGYOjoyOenp5cu3aNb7/9lsaNG+Pu7s6BAwfU+fv3788XX3xB9+7dadCgAcOHD+fhw4fAf6ca/f39ad68OQMHDgRg/fr1vPnmmzRs2JB33nmHO3fuAE8qtpkzZ9K4cWMaNGiAp6enuq379u2jQ4cOODo64ubmxrJly4AXT3NfuXKF/v374+TkRMeOHfnjjz/UaT4+PkydOpWhQ4fi6OhIjx49uHnzZnZeilTb9eyLrX///ixYsIDevXvj6OjIsGHDePDgAaNHj6Z+/fp069aN27dvp8r49ttv4+zsTLt27dixY0ea61EUBV9fX4YPH06nTp0wNzenTJkyfP7551hYWLBixQri4+NxcnJS9xNAeHg4derUISwsDHhyJsTLywsnJyd69+7NhQsX1HlbtmzJ0qVL8fT0pF69emoT0LZt22jevDkuLi4sWbJEnT85OZmlS5fSunVrXFxc+Oijj9TXG54cJJo0aUKDBg3o27cvly5dUqc9ePCAYcOGUb9+fbp3756tfV+qVClcXV25cuVKutkTExM5deoUvXv3xsnJiU6dOqU6lb1hwwbefPNNHB0dadWqFWvXrk13fStXrqRDhw7cvXsXePKLrWnTpjRt2pT169enmjciIoJPP/2URo0a0aJFC/z8/EhOTgagRYsWBAYGArBlyxbs7Oy4fPkyAP7+/rz//vvAk8/dRx99xKeffoqjoyMdO3bk7NmzaWZbtGgR06dPByAhIYF69eoxZ84cAGJjY6ldu3aqAjQnr+Wz9/imTZvSfO7zMvts/f3333Tr1o0GDRrQrVs3/v77bwAWLFjAiRMnmDZtGo6OjkybNi3VcuPj49WmSS8vL/VMRkaf8+dPjT/fLGdnZ8dPP/1E27ZtadiwIVOnTuXZDZiTkpLw9fXFxcWFVq1asW/fvnS3GZ68Bw8dOgRk7zUEuHTpknoccHV15ZtvvgHgzJkz9OrVCycnJ5o2bcq0adOIj4/P9Hnw5P2Q3vpDQkL48MMPadSoES1btmTlypVp5rp16xZOTk7qe3jChAk0btxYnT5mzBhWrFiRal9fuXKFKVOmcOrUKRwdHXFyclLnf/z4cZaOuYcOHeLQoUP4+flRp04dTExMKFq0KH379lXPcmX2GU7vOw/gzp076jF68ODBhIeHq9MyOm6kdO3aNQA8PDzQ6XSYm5vTtGlT7O3tgdTvte+++w5HR0f1X82aNfHx8QGeHDPGjx9P06ZNcXNzY8GCBek2v9++fZsGDRpQoUIFdDodnTp1Uo8hGVIy0aJFC+XgwYMvPO7u7q6sXr1aURRFmTFjhvLee+8pDx48UCIiIpT33ntPmTdvnqIoinL69Gmlfv36yoEDB5SkpCTl7t27yuXLlxVFUZS+ffsqU6ZMUWJjY5Vz584pLi4uyqFDhxRFUZRFixYptWrVUvbv368kJCQon3zyidKiRQvFz89PiY+PV37++WelRYsWap5+/fopTZs2Vf79918lKipKGTFihDJ69GhFURTl1q1biq2trfLJJ58oUVFRSkxMjPLbb78prVu3Vi5fvqwkJCQoX3/9tdKrVy9FURRl//79SpcuXZRHjx4pycnJyuXLl5WQkBBFURSlSZMmyvHjxxVFUZSHDx8qgYGBiqIoypEjRxQ3NzdFURQlPj5ead26tbJkyRIlLi5OOXTokFKvXj3lypUriqIoytixY5WGDRsqp0+fVhISEpRRo0YpI0eOzPB1eLYNCQkJ6T7Wr18/pXXr1sqNGzeUx48fK2+++abStm1b5eDBg+o+9PHxURRFUaKiopRmzZop69evVxISEpTAwEDF2dlZuXjx4gvrvnz5smJra6vcvHnzhWkLFy5UevbsqSiKovj4+Cjz589Xp61atUoZPHiwoiiKEhgYqDRq1Eg5deqUkpiYqGzcuFFp0aKFEhcXpyjKk/dZp06dlKCgICUmJkbdtgkTJigxMTHK+fPnlZo1a6rvneXLlys9evRQgoODlbi4OGXSpEnKxx9/rK7b399fiYiIUOLi4pQZM2YonTp1UqeNHDlS8fb2VqKiopR///1Xadq0qdK7d+8s7fe7d+8qnp6eir+/vzrP89nv3r2rODs7K3v37lWSkpKUAwcOKM7OzkpYWJiiKIqyZ88e5caNG0pycrJy9OhRpU6dOmm+j7766iulc+fO6vP27dunNG7cWH2Pjxo1SrG1tVWuX7+uKIqifPLJJ8qwYcOUiIgI5datW0rbtm2VdevWqdOWLVumKIqiTJw4UWnVqpX6+f3kk0+U5cuXK4ry3+du7969SmJiojJv3jylR48eae6bQ4cOKR4eHoqiKMpff/2ltGrVSunevbs6zdPTM9U+zMlrmdlzn5fRZ+vBgweKk5OTsmnTJiUhIUHZtm2b4uTkpISHhyuK8uTz82x/pSfl/s7sc/788jZs2JDqfWZra6sMHTpUefTokXLnzh3FxcVF2bdvn6IoirJmzRqlXbt2SlBQkPLgwQOlX79+L3z+U0p5nM7OaxgREaE0adJEWbZsmRIbG6tEREQop06dUhRFUc6ePaucPHlSSUhIUG7duqW0b99efZ9k9LyM1p+UlKR06dJFWbx4sRIXF6fcvHlTadmypbJ///4087m7uytnz55VFEVR2rZtq7Rs2VJ97d3d3ZV//vnnhX39/H5WlOwdc+fOnav07ds3zWnPZPQZzug7r1+/fkqrVq2Uq1evKjExMUq/fv2UuXPnKoqiZHrceP51c3Z2Vj799FNl7969ysOHD1NNT2sfKIqiBAUFKU2aNFH27t2rKIqiDB8+XJk0aZISFRWl3L9/X+nWrZvy008/pbnNt2/fVjp37qxcvXpViY+PV3x9fZXhw4dnuJ8URVFy3KnCysqKR48eoSgK/v7+jB8/nuLFi2Npacl7772nthGuX7+ebt260aRJE4yNjbG2tqZatWoEBwfz119/MWbMGAoVKoSDgwM9evRgy5Yt6jqcnJxwc3PDxMSE9u3b8+DBA4YOHYqpqSkdOnTgzp07PH78WJ3fy8sLW1tbLCws+Oijj9i5c2eqquzDDz/EwsICc3Nz1q5dy9ChQ6lWrRomJiYMGzaM8+fPc+fOHUxMTIiKiuLq1asoikK1atWwsrICwMTEhMuXLxMZGclrr71GzZo1X9g3p0+fJjo6mqFDh2JmZkbjxo1p0aJFqnbTNm3aqFVyp06dOH/+fE5filS6du1KxYoVKVq0KM2aNaNChQq4urqq+/BZZ7W9e/fy+uuv061bN0xMTKhZsybt2rVLs1/JgwcPANR9kFKZMmXU6Z6enmqzDjz55erp6QnAunXr6NWrF3Xr1kWn09GlSxdMTU05deqUOn///v2xsbHB3NxcfWzEiBGYm5tjb2+Pvb29evbj559/5uOPP6Zs2bKYmZkxYsQIfv31V/WsTvfu3bG0tMTMzIwPP/yQCxcuEBERQVJSErt27cLb2xsLCwtsbW3p0qVLpvu1UaNGODk50axZMywsLGjfvn2q6Smzb9myhWbNmuHu7o6xsTFNmjShVq1a6q/R5s2bU7FiRYyMjHB2dqZJkyacOHFCXZaiKMyaNYsDBw6wcuVKSpYsCTw5Xdm1a1f1PT5ixAj1OUlJSezYsYPRo0djaWlJ+fLlefvtt9m6dSsADRs25NixY8CTttz33nuP48ePA0+agho2bKguq0GDBri7u6PT6fDy8kp1xiklR0dHrl+/zoMHDzhx4gTdu3cnJCSEqKgojh8/jrOzc6r5c/paZvTctKT32dq7dy+VKlWic+fOmJiY4OHhQdWqVdmzZ0+6y8pIVj7nmRkyZAjFihWjXLlyuLi4qNv1yy+/MHDgQGxsbChevDjvvfdetrJl9TXcu3cvpUuXZvDgwRQqVAhLS0vq1q0LQK1atahXrx4mJiaUL1+eXr16qe+ZjJ6X0frPnj1LeHi4emq/QoUK9OzZM92zqA0bNuT48ePcu3cPgHbt2nHs2DFu3bpFZGSk+ss9K7J6zH348CFlypTJcFkZfYbT+857pmvXrlSpUgVzc3Pat2+v5sjsuJGSpaUla9aswcjIiEmTJtG4cWOGDRvG/fv3080cGxvLBx98wIABA3B3d+f+/fvs37+f8ePHY2FhQalSpRg0aFC6798yZcrQoEED2rdvT926ddm5cyfjxo3LcD9BFjp+pickJITXXnuN8PBwYmJi6Nq1qzpNURT1FFdwcDDu7u4vPD80NJTXXnsNS0tL9bFy5cqpp3ThyanpZ8zNzSlRogQ6nU79GyA6OppixYoBYGNjk2pZCQkJ6hcgkKqDYlBQEDNnzsTX1zdV7pCQEBo3bkzfvn2ZNm0aQUFBtGnThrFjx2JpacmiRYtYsmQJX3zxBXZ2dowePRpHR8cXtq1s2bKpOsaWK1eOkJAQ9e/SpUun2rbo6OgX9lFOpFxuoUKF0l3PnTt3OHPmTKrTiUlJSWl2FipRogTwZLsqVKiQatq9e/fU6Y0aNSIuLo7Tp09TunRpLly4oJ5WDgoKYvPmzaxatUp9bkJCAqGhoerfKV+/tLancOHCav6goCA++OCDVPvY2NiYsLAwSpcuzYIFC9i5cyfh4eHqPA8ePCA2NpbExMQX3iuZOXLkCCYmJsTGxrJw4ULefffdVKdIUy4vKCiInTt3pvrySkxMxMXFBXjS5Pb1119z/fp1kpOTiY2NxdbWVp03IiKCdevWsWDBAooWLao+HhoaSq1atdS/X3/9dfX/Dx48ICEhIdW2pHzPOTs7M2fOHO7du0dycjJvvvkmX331Fbdv3yYiIgIHB4c097m5uTlxcXEkJiZiYpL6cGFubk6tWrU4fvw4x48fVwv1v//+m+PHj9OvX79U8+fktczsuWlJ7z0fGhr6wmv9/OcyO7LyOc9Myi+zwoULExUVpS47u+/RlLL6GgYHB1OxYsU0l3Ht2jVmz55NYGAgMTExJCUlqT+qMnpeRuu/c+cOoaGhLxx3Uv6dkrOzM3/88QfW1tY0bNgQFxcXtmzZQqFChXBycsrWxQdZPeYWL16c69evZ7isjD7D6X3nPfP8a57yc5DRceN51apVY/bs2cCTZrtPPvmEmTNnMn/+/DTnnzBhAlWqVGHo0KHq+hITE2natKk6T3JycprHYYCvv/6awMBA9u3bR+nSpdm6dSsDBw5k+/btFC5cON3tzVGRcebMGUJCQmjQoAElSpTA3Nyc7du3Y21t/cK8NjY2abZ9PTsTEhkZqRYawcHBaS4jq4KDg1P939TUlBIlSqiPGxkZpco1bNiwdHvgDhgwgAEDBhAWFsbIkSP5/vvvGTlyJHXq1GHJkiUkJCSwevVqRo4c+UKlaWVlxd27d0lOTlY/BMHBwVSuXDnH25bbbGxsaNiwIcuXL8903qpVq1K2bFl27typXu0CT96Qu3btolWrVsCTL4b27dsTEBBA6dKlad68ufraPtvfw4cPT3c9KV+fzJQtW5aZM2fSoEGDF6Zt3ryZP/74g+XLl1O+fHkiIiJo2LAhiqJQsmRJTExMCA4OVn9dpHzfZMbc3JyuXbvyv//9j/DwcPUsw/PvLS8vL2bMmPHC8+Pj4/H29sbX15dWrVphamrK+++/r7bFAxQrVoy5c+cycuRIvvrqK3UbraysUmUNCgpS/1+iRAlMTU0JCgrijTfeULfr2eepUqVKmJub8+OPP+Lk5ISlpSWlS5dm3bp1NGjQIMdXijk7O3PkyBHOnz9P7dq1cXZ25sCBA5w5cybV2ZGMZPRapuxD9LKsrKxS7TN4so/c3NxyvLyMPueFCxcmJiZGnT+jX5nPK1OmzAvHM32wsbFJ95frZ599Ro0aNfjiiy+wtLRkxYoV6pnOjJ6X2frKly/Prl27sjR/w4YNmTNnDmXLlqVhw4Y0aNCAKVOmUKhQoXTfX9k5jqTF1dWVlStXcvfu3TSvnMvsM5zed15mMjpuZKZatWp07dqVn3/+Oc3pS5cu5dq1a6xZs0Z97NmZw2c/oDJz4cIF3nzzTXWfdO3alZkzZ3L58mVq166d7vOydWSJjIxkz549jBo1ik6dOmFnZ4exsTE9evRg5syZ6i+PkJAQ/vzzT+DJaeuNGzdy+PBhkpOTCQkJ4cqVK9jY2ODo6Mj8+fOJi4vjwoULrF+/Xj29nhNbt27l8uXLxMTEsHDhQtq1a6ee+Xhe7969Wbp0qdohMCIigl9++QV4UkSdPn2ahIQEChcujJmZGTqdjvj4eLZu3UpERASmpqYUKVIkzeXXqVOHwoUL8/3335OQkMDRo0fZvXs3HTp0yPG25bbmzZtz/fp1Nm/eTEJCAgkJCZw5cyZVh8ZnjIyMGDt2LEuWLGHbtm3ExsZy7949JkyYQGRkJIMGDVLn9fT05JdffmHbtm14eHioj/fo0YO1a9dy+vRpFEUhOjqavXv3EhkZmaP8b731Fl9++aXaWTc8PJzff/8dgKioKMzMzChRogQxMTGpKnudTkebNm346quviImJ4fLlyxleX/+8+Ph4tmzZQpkyZdQzOM/r1KkTe/bs4c8//yQpKYm4uDiOHj3K3bt3iY+PJz4+Xi129u3bx8GDB19YhouLC/PmzWPEiBGcPn0agPbt27Np0yb1Pf7VV1+l2q727duzYMECIiMjuXPnDsuXL09VRDs7O7Nq1Sr14Pz83znRsGFDNm/eTLVq1TAzM8PZ2Rl/f3/Kly+vFmCZyei1zE3u7u5cv36dbdu2kZiYyI4dO7h8+TLNmzcHnvzSvXXrVpaXl9nn3MHBgd9++42YmBhu3LjxQkfdjLz55pv8+OOP3L17l0ePHrF06dJsbWtWNW/enPv376udtyMjI9X3W1RUFEWKFKFIkSJcuXIl1SWhGT0vI3Xq1MHS0pKlS5cSGxtLUlISFy9e5MyZM2nOX7lyZQoVKsTWrVtp2LAhlpaWlCpVil9//TXd922pUqUICQlJ1Uk1O1xdXXF1deWDDz4gMDCQxMREIiMj+emnn1i/fn2mn+H0vvMyk9Fx43lXrlzhf//7nzotODiYgICAVE1Wz+zbt4+VK1fy9ddfp2qKtrKyokmTJsyePZvIyEiSk5O5efOm2qz6vNq1a7Nz507u379PcnIymzdvJjExkUqVKmW4XVkqMoYNG4ajoyPu7u588803vP3228yaNUud/sknn1CpUiV69uxJ/fr1GTRokNr7tU6dOsyaNUv9pdKvXz/118T8+fO5c+cObm5ujBgxgg8//JAmTZpkJVKavLy88PHxoUmTJsTHx2d4mW2bNm149913GTVqFPXr18fDw0PtARwVFcXEiRNxdnamRYsWFC9eXL2xyZYtW2jZsiX169dn7dq1am/6lMzMzFiyZAn79++nUaNGTJ06lTlz5qRql8trlpaWLFu2jB07duDm5kbTpk2ZN29euh/MDh06MGfOHFasWEGjRo3o2LEjcXFx/PTTT6m+bOvWrUvhwoUJDQ1NdbVN7dq1mT59OtOmTaNhw4a0bduWjRs35jj/gAEDaNmyJYMHD8bR0ZGePXuqB6rOnTtTrlw53Nzc6NixI/Xq1Uv13MmTJxMdHU2TJk3w8fFJ1dSXnoYNG+Lo6IirqyunTp3Cz88v3V9MNjY2+Pn5pboSatmyZSQnJ2NpacnEiRMZOXIkDRs2JCAggJYtW6a5nCZNmjBr1iyGDx9OYGAg7u7uDBw4kIEDB9KmTRsaNWqUav5JkyZRuHBhWrduTZ8+ffDw8KBbt26ptiEqKipVkZHy75xwdHQkLi5OXcYbb7yhnsrOqoxey9xUokQJvvnmG5YvX46Liwvff/8933zzjVoMDRgwQP3yysqvycw+5wMHDsTU1BRXV1fGjh2brR9QPXv2pGnTpnh5edGlSxfatm2bs43OhKWlJf/73//Ys2cPTZo0oV27duoVDWPHjiUgIID69eszadKkVD+SMnpeRnQ6HUuWLOHChQu0atWKRo0aMXHixAx/bDg7O1O8eHG1ycjZ2RlFUahRo0aa8zdq1Ig33niDpk2bptvUkJlFixbh7u7Oxx9/jJOTE56engQGBuLq6prpZzij77yMZHTceJ6lpSWnT5+mR48e1KtXj549e2Jra6teNZLSL7/8woMHD9SrIh0dHZk8eTIAc+bMISEhgQ4dOtCwYUO8vb3V/i/PGzJkCPb29nTu3BknJyd++OEHFi1apHZXSI+RkvI87SssKzfSEUIIIYThyC07hRBCCKEXUmQIIYQQQi/yTXOJEEIIIbQlx/fJEPqRnJxMVFQUpqamL30plhBCFBSKopCQkECRIkVk8E4NkSJDY6KiolKN/yGEECLrbG1tU93ETuQtKTI05tnw4ba2ti81ol5gYGCqu0PmFS3kkAzayqGFDFrJoYUMWsnxshni4+O5ePGiegwV2iBFhsY8ayIxMzOjUKFCL7Wsl31+btFCDsnwHy3k0EIG0EYOLWQAbeTIjQzSzKwt0nAlhBBCCL2QIkMIIYQQeiFFhhBCCCH0QooMIYQQQuiFFBlCCCGE0AspMoQQQgihF1JkCCGEEEIvpMgQQgghhF5IkSGEyFWxibEZTm/QoMFLL0MI8WqQO34KIXKVuYk5RlNf7q6LyhQZHDo3xSbGYm5inu70zAq/zJ4vRHqkyBBCiHzuZQs/KfpETklziRBCCCH0QooMIfKRl+0PIX0hhBC5SZpLhMhH5LS4EEJL5EyGEEIIIfRCigwhhBBC6IUUGUKIfEkL/VPkniH/kX1RMEmfDPHKk3sAiLRooX+K3DPkP7IvCiYpMrLp2rVr+Pj48PDhQ4oXL46vry+VK1dONc/ixYtZs2YNVlZWANSvX58pU6bkQdqCQQtfJkIIIV4kRUY2TZkyhT59+uDl5cWWLVuYPHkyK1eufGG+zp07M3bs2DxIKIQQQmiD9MnIhrCwMM6dO4eHhwcAHh4enDt3jvDw8DxOJoQQQmiPFBnZEBwcjLW1NTqdDgCdToeVlRXBwcEvzLt9+3Y8PT0ZPHgwJ0+eNHRUIYQQIs9Jc4ke9O7dm2HDhmFqasrBgwd5//332bFjByVKlMjyMgIDA186x19//fXSy8gN+s6RlV7pmTHEvjLEOrSwL3Ijg1ZyaCGDVnJoIUNu5BCGJUVGNtjY2BASEkJSUhI6nY6kpCRCQ0OxsbFJNV+ZMmXU/zdp0gQbGxsuXbqEs7NzltdVq1YtChUqlOOsf/31V659qF+GVnJkRt8ZX5X9APrfF1mlhRxayADayKGFDJB+jri4uFz5cSZylzSXZEOpUqVwcHAgICAAgICAABwcHChZsmSq+UJCQtT/nz9/njt37lClShWDZhVCCCHympzJyKbPPvsMHx8f/Pz8KFasGL6+vgAMGTIEb29vateuzfz58/nnn38wNjbG1NSUOXPmpDq7IYQQQhQEUmRkU7Vq1fD393/h8e+++079/7PCQwghhCjIpLlECCGEEHohRYYQQggh9EKKDCGEEELohRQZQgghhNALKTKEEEIIoRdSZAghhBBCL6TIeEXFJsZmOD2zu/Nl9vzcyGCoHEIIIbRJ7pPxijI3McdoqlGOn69MUfI8Q27lEEIIoU1yJkMIIYQQeiFFhhBCCCH0QooMIYQQQuiFFBlCCCGE0AspMoTIBS97tU9WliGEEK8aubpEiFwgV9oIIcSL5EyGEEIIIfRCigwhhBBC6IUUGUIIIYTQCykyhBBCCKEXUmQIIYQQQi+kyBBCCCGEXkiRIYQQQgi9kCJDCCGEEHohRYYQQggh9EKKDCGEEELohRQZQgghhNALKTKEEEIIoRdSZAghhBBCL6TIEEIIIYReSJEhhBBCCL2QIkMIIYQQeiFFRjZdu3aNXr160a5dO3r16sX169fTnffq1avUrVsXX19fwwUUQgghNEKKjGyaMmUKffr04ddff6VPnz5Mnjw5zfmSkpKYMmUKrVu3NnBCIYQQQhukyMiGsLAwzp07h4eHBwAeHh6cO3eO8PDwF+ZdunQpzZs3p3LlygZOKYQQQmiDSV4HeJUEBwdjbW2NTqcDQKfTYWVlRXBwMCVLllTnu3DhAgcOHGDlypX4+fnlaF2BgYEZTm/QoEGOlpvSX3/99VLPz40MWsmhhQxayaGFDFrJoYUMWsmhhQy5kUMYlhQZuSwhIYFJkyYxa9YstRjJiVq1alGoUKFcTPai3PrQvywt5NBCBtBGDi1kAG3k0EIG0EYOLWSA9HPExcVl+uNMGJ4UGdlgY2NDSEgISUlJ6HQ6kpKSCA0NxcbGRp3n3r173Lx5k6FDhwLw+PFjFEUhMjKS6dOn51V0IYQQwuCkyMiGUqVK4eDgQEBAAF5eXgQEBODg4JCqqaRcuXIcPXpU/Xvx4sVER0czduzYvIgshBBC5BkpMrLps88+w8fHBz8/P4oVK6ZenjpkyBC8vb2pXbt2HicUIm/FJMSgTFFeehmFTQvnUiIhRF6RIiObqlWrhr+//wuPf/fdd2nO/+GHH+o7khCaUti0MLNP3n+pZfg4ls6lNAJevvCTok/klBQZQgiRz71s4SdFn8gpKTKEyEfkF6sQQkukyBAiH5FfrEIILZEiQwiRqxKTkl+6WElMSsZEJzckFuJVJ0WGECJXmeiMwcjo5ZahvNzVKVqhlSttXrbwy42iTyv7QhiWFBnilSf9EERatPC+0MqVNi9b+OVG0aeVfSEMS4oM8cqTfgj/0cIvVq2Q94UQeU+KDCHyES38YhVCiGekyBBCCD2RTrCioJMiQwgh9EQ6wf5HCq6CSYoM8cqTfggiLfK+0BYpuAomKTLEK0/6IYi0yPtCiLwnZboQQggh9EKKDCGEEELohRQZQgghhNAL6ZMhckxuEyyEECIjUmS8ouSWyUIIIbROioxXlNwyWQghhNYViCIjPDycLVu2sHfvXi5cuEBkZCSWlpbY29vTrFkzunTpQsmSJfM6phBCCJGv5Psi44svvmDr1q24u7vTvXt3qlWrRpEiRYiKiuLKlSscP36cLl264OnpyZgxY/I6rhBCCJFv5Psiw8rKit9++w0zM7MXptWoUQNPT0/i4uLw9/fPg3SvNrlNsBBCiIwYKYrc1k5L4uLiCAwMpFatWhQqVCjd+V72yznXvtxf8jbB5Nbb72Vy5EKG3OhIm2tX2uTxvnjpDFrJoYUMWsmhhQyZ5MjqsVMYVr4/k5HSkSNHeP3116lQoQKhoaF88cUXGBsbM2rUKMqUKZPX8bJFbpmsLXKljRBCvKhAnaeeOnUqOp0OAF9fXxITEzEyMmLSpEl5nEwIIYTIfwrUmYyQkBDKlStHYmIiBw4cYPfu3ZiamuLm5pbX0YQQQoh8p0AVGZaWlty/f59Lly6pV5nEx8eTmJiY19GEEEKIfKdAFRn9+vWje/fuJCQkMH78eAD+/vtvqlatmsfJxKtOrrQRQogXFagiY+jQobRp0wadTkfFihUBsLa2ZsaMGXmcTLzqXrYjLkhnXCFE/lOgigyAKlWqZPi3EEIIIXJHvj83261bN3755Rfi4+PTnB4fH8+OHTvo0aOHgZMJIYQQ+Vu+P5Ph6+vLokWL+Oyzz6hZsyZVqlRRbyt+/fp1/vnnHxo1asTs2bOztLxr167h4+PDw4cPKV68OL6+vlSuXDnVPBs2bGDFihUYGxuTnJxMjx49GDBggB62TgghhNCuAnPHz3v37nHw4EEuXrxIREQExYoVw87OjiZNmlCqVKksL2fAgAF069YNLy8vtmzZwoYNG1i5cmWqeSIjIylSpAhGRkZERkbi6enJkiVLsLe3z3T52bprXT6/g5/Bcmghg1ZyaCGDVnJoIYNWcmghQyY55I6f2pTvz2Q8U6ZMGTp37vxSywgLC+PcuXMsX74cAA8PD6ZPn054eHiqUVwtLS3V/8fGxpKQkIDRy364hBBCiFdMgSkyckNwcDDW1tbqXUN1Oh1WVlYEBwe/MFT8H3/8wfz587l58yajR4/Gzs4uW+sKDAzMcHqDBg2yFz4Nf/3110s9PzcyaCWHFjJoJYcWMmglhxYyaCWHFjLkRg5hWAWmuSQ3BAYGMnbsWLZv364+1qFDB+bOnUvNmjXTfE5QUBAffPABX3zxRZbuxyHNJXmQQwsZtJJDCxm0kkMLGbSSQwsZMskhzSXalO+vLslNNjY2hISEkJSUBEBSUhKhoaHY2Nik+5xy5cpRu3Zt9u7da6CUQgghhDZIkZENpUqVwsHBgYCAAAACAgJwcHB4oankypUr6v/Dw8M5evQotra2Bs0qhBBC5LUC1SdDURT8/f0JCAjgwYMHbNu2jePHj3Pv3j06dOiQpWV89tln+Pj44OfnR7FixfD19QVgyJAheHt7U7t2bX7++WcOHjyIiYkJiqLQr18/mjZtqs9NE0IIITSnQPXJ+PLLLzl06BADBw5kypQpnDhxglu3bvHRRx+xcePGvI4HSJ+MPMmhhQxayaGFDFrJoYUMWsmhhQyZ5JA+GdpUoJpLNm3axDfffEPHjh3VS0rLly/PrVu38jiZEEIIkf8UqCIjKSmJIkWKAKhFRlRUFBYWFnkZSwghhMiXClSR4e7uzqxZs9RxTBRFYeHChbRo0SKPkwkhhBD5T4EqMsaNG0doaCgNGjQgIiICR0dHgoKCGDNmTF5HE0IIIfKdAnV1iaWlJX5+fty/f5+goCBsbGwoU6ZMXscSQggh8qUCdSbjGXNzc6ytrUlOTiYkJISQkJC8jiSEEELkOwXqTMahQ4eYNGkSQUFBpLxy18jIiPPnz+dhMiGEECL/KVBFxoQJE3j//ffp0KED5ubmeR1HCCGEyNcKVJERFxdH165d1VFUhRBCCKE/BapPxqBBg/j+++8pQDc5FUIIIfJMgTqT0bZtW9555x2+/fZbSpQokWraH3/8kUephBBCiPypQBUZ3t7eODk50b59e+mTIYQQQuhZgSoybt++zebNmzE2LlCtREIIIUSeKFDftq1ateLIkSN5HUMIIYQoEArUmYz4+HiGDx+Ok5MTpUqVSjVtzpw5eZRKCCGEyJ8KVJFRvXp1qlevntcxhBBCiAKhQBUZI0aMyOsIQgghRIGR74uM48eP07BhQwAOHz6c7nyNGzc2VCQhhBCiQMj3RcbUqVMJCAgAntxWPC1GRkZynwwhhBAil+X7IiMgIICAgAA8PDzYvXt3XscRQgghCowCcQnr5MmT8zqCEEIIUeAUiCJDxioRQgghDC/fN5cAJCcnc+TIkQyLDen4KYQQQuSuAlFkxMfHM2HChHSLDOn4KYQQQuS+AlFkFC5cWIoIIYQQwsAKRJ8MIYQQQhhegSgypOOnEEIIYXgFosg4efJkXkcQQgghCpwCUWQIIYQQwvAKRMfP3HTt2jV8fHx4+PAhxYsXx9fXl8qVK6ea5+uvv2bHjh3odDpMTEz4+OOPcXNzy5vAQgghRB6RIiObpkyZQp8+ffDy8mLLli1MnjyZlStXppqnTp06DB48mMKFC3PhwgX69evHgQMHMDc3z6PUQgghhOFJc0k2hIWFce7cOTw8PADw8PDg3LlzhIeHp5rPzc2NwoULA2BnZ4eiKDx8+NDQcYUQQog8JUVGNgQHB2NtbY1OpwNAp9NhZWVFcHBwus/ZvHkzFStWpGzZsoaKKYQQQmiCNJfo0bFjx1i4cCH/+9//sv3cwMDADKc3aNAgp7FUf/3110s9PzcyaCWHFjJoJYcWMmglhxYyaCWHFjLkRg5hWEaK3EQiy8LCwmjXrh1Hjx5Fp9ORlJSEi4sLu3btomTJkqnmPXnyJCNHjsTPz4+aNWtmeR1xcXEEBgZSq1YtChUqlPHMRkY52Ywncutlf5kMWsmhhQxayaGFDFrJoYUMWsmhhQyZ5MjWsVMYjDSXZEOpUqVwcHAgICAAgICAABwcHF4oMM6cOcPHH3/MokWLslVgCCGEEPmJnMnIpitXruDj48Pjx48pVqwYvr6+VK1alSFDhuDt7U3t2rXp1q0bd+7cwdraWn3enDlzsLOzy3T5ciYjD3JoIYNWcmghg1ZyaCGDVnJoIUMmOeRMhjZJkaExUmTkQQ4tZNBKDi1k0EoOLWTQSg4tZMgkhxQZ2iTNJUIIIYTQCykyhBBCCKEXUmQIIYQQQi+kyBBCCCGEXkiRIYQQQgi9kCJDCCGEEHohRYYQQggh9EKKDCGEEELohRQZQgghhNALKTKEEEIIoRdSZAghhBBCL6TIEEIIIYReSJEhhBBCCL2QIkMIIYQQeiFFhhBCCCH0QooMIYQQQuiFFBlCCCGE0AsjRVGUvA4h/hMXF0dgYCC1atWiUKFCGc9sZJTzFaXzsickJHD79m1iY2OztpwbN3KeAaBSpZd7fm7k0EIGreTQQgat5NBCBq3kyGIGc3Nzypcvj6mpadozvMwxC9I9bkE2j53CYEzyOoDQltu3b1O0aFEqV66MUVYOCFFRL7dCB4eXe35u5NBCBq3k0EIGreTQQgat5MhCBkVRCAsL4/bt21SpUiXn6xL5ijSXiFRiY2MpVapU1goMIYR4ysjIiFKlSmX9LKgoEKTIEC+QAkMIkRNy7BDPk+YSkbnYWDA3T3uak1POlxsRkfPnCiGE0DwpMkTmzM1fvsNWWrLQ57hly5aYmZlhZmZGTEwMb7zxBkOGDKF+/fq5n+cVcPbsWVasWMEXX3yRK8v7YMECboeGAnDh5k1sbW0xNjamdOnStG7dmri4OAYNGpQr60pLTFwcfadPZ9XEiViYm6MoCit//ZV1U6agKArJyck4OTnx6aefUqxYsWwvf+O+few9eZJFI0fmam47Ozv+/vtvihQpkqvLfRWMHDmSAQMGFNjPoMgeKTKE5i1atAhbW1sAdu3axdChQ1m2bBl169bN42RZk5iUhIlOlyvLql27dq4VGABff/yx+n+7vn1Zu3atQb84f9y1i3YNG2Lx9EzZl/7+HL9wgR9++IHSpUuTnJzM77//zqNHj3JUZAhITk7GyMiI3PqZMGzYMGbMmMGqVatyaYkiP5MiQ7xS2rZty5kzZ1i2bBmLFi0iPj6eBQsWcHzvXhISE7GtUIHPBg+miLk5EdHRzFy1isArVzAyNsbJzo7JgwYRFRvLjB9+4OzVqwB06tWLoUOHAtC/f39q1qzJmTNnuHPnDgMGDMDa2ppVq1YRGhrKJ598wptvvgk8+TU7YsQIDh48yIMHDxjl5UU7Z+cn0/r25ZO33mLfqVM0sLPj3Y4dmbV6Nf/evElcQgIuNWowrl8/dMbGfLVhAwGHD1PotdcwMjJi5cqVmJqaMnbsWC5fvoyJiQlVqlRh4cKFHD16FF9fXzZu3AjA5s2bWbZsGQAVK1Zk2rRplOLJL/iAQ4coVqQIl27fpqiFBYtHjqRM8eJZ3teLFy8mOjqasWPHsnHjRgICAihatCj//vsv1tbWTJo0iTlz5nDjxg1q1arFvHnzMDIyIjIyklnffZfmtj5v3e7d/DB+PABRsbEs37GDzTNnUrp0aQCMjY1p27YtAPfu3WPUqFFERUURFxeHu7s7n376KYD6Pvjzzz8xNjamQoUKfP311wBExsQwctGiNPfDd9u28euxYyQlJ2NdogTT3303zX20a9cu5s+fT/HixWnWrFmqaadPn2bevHlEPb16w9vbm+bNmwOwZ88eFvv6kpiUhLGREbOHDcO+YkX2nz7N/J9/Jik5mZLFijFt8GAqlS3L0XPn+PzHH6lTtSqnn772c776iq+++opLly5hY2PD4sWLsbCwYPHixVy+fJno6GiCgoKoWrUqM2fOpGjRoixevJgbN24QHR3NrVu3WLVqFadOnWLJ5s3EJyRgamLCuH79qFe9OleDghj37bfExMeTnJxMl2bNeKdjR34/cYKF/v4YGxuTVKgQkyZNwsXFBXt7e8LCwrh+/TqVK1fO8vtJFExSZIhXTt26ddm9ezcA33//PUWLFmX99OkAzP3pJ5Zu3crHPXsy88cfsTA3Z8usWRgbGxP+tA+I36ZNJCsK22bPJiomhl6+vtjZ2eHu7g7A3bt3WbVqFffu3aNt27YMGjSItWvXcubMGUaMGKEWGfCko9vatWu5evUqb/XogZOdHaVeew2AZEXhx4kTAZjw3Xc0tLfn8yFDSE5OZoyfHxv27qWdiwvLduzg8JIlmLu6EhkZibm5OXv27OHx48fs2LEDgEePHr2wHy5evMi8efPYuHEjVlZWfPnll0yfPp0v+/UD4OzVq2ydPRubUqWY+N13rNq1i4979szxfj979izbtm2jbNmyvPfee4wePZpVq1ZRuHBhunTpwuHDh3F1dWXWrFlpbmvPli1TLS84LIyYuDheL1MGgCt37mBmakrVcuXSXH+xYsX45ptvKFKkCAkJCbzzzjvs37+fZs2asXTpUm7dusXGjRsxMzMjPDz8v9zp7IctBw5wMySEdVOnYmxszJrff2f26tV88cEHqdYbFhbGpEmT+Omnn6hatSrfffedOu3x48dMmTKFpUuXYmVlRWhoKN27dycgIICwsDAmTpzI6nHjqFy2LPEJCcQnJhL26BGfLlnCqokTeaN8efz37mWMnx/+06ap+8H3vfeYMWQIU5cv55133mHdunWULVuWIUOGsH37dnr06AHAX3/9xebNmyldujTjxo3Dz8+PsWPHAnDixAk2btxIyZIluXnzJn6bNrFs7FgsLSy4dPs2Q+bMYe+iRaz5/Xea1avHB126APDoabG0aMMGprz9Nk729iQ5OhITE6Nud7169Th8+LAUGSJTUmSIV07K+8ft3r2byMhIft20CYD4xETsK1YEYM/Jk2ycMQPjp7+gSxYtCsDhwEDGDxiAkZERlhYWdOzYkcOHD6tFRvv27TE2Nsba2prixYvTunVrAGrWrElISAhxcXHqzX6eHeyrVq1KjcqVOXX5Mq0aNACgi5vbfzn//pszV66w/GnREBsfj3XJklgWLkwVGxs+8fPD7fZtmjdvjqWlJfb29ly9epWpU6fi7Oys/jJO6ejRo7i7u2NlZQVA79698fLygqdFRn1bW2xKlQKgbvXqHDp79qX2e/369SlbtiwADg4OvP766xR9uk/t7e25ceMGrq6u7N69mzNFirywrc+7Gx6uFmSQ+nVNS1JSEnPmzOHkyZMoisL9+/e5cOECzZo1Y8+ePfj4+GBmZgZAyRTrS28/7P77bwKvXqXLhAlPlp+cjGXhwi+s99SpU9SoUYOqVasC0KtXL+bNmwfAyZMnuX37NkOGDFHnNzIy4saNG5w5c4ZmzZpR+ek+MzM1xczUlGPnz2NfsSJvlC8PQLdmzZi6fDmRT7/Eq9jY4PD0y7tGlSoEJSaq+71mzZrcSHFTrebNm6tnfbp3786MGTPUac2aNVP3w59//snN0FD6Pi3G4Ukz3v1Hj2hob4/vmjUkJCbiUqMGjWrUAKBRjRrMXr2a9i4uNCtWTG2yBChTpgx3797N8PUSAqTIEK+gs2fPUr16deDJF9OUKVNonN4dBtOgwAvt0ykvvUt5t0CdTqf+rXvaryIxMTHNOwoqipJqORYprshRFAW/UaOo8LQgSGnd1Kn8ffEiR+7epWvXrnz//ffY29uzY8cOjhw5wv79+1mwYAHbtm3LcH3PK5Rin+iMjEhKSkp33qxIb788+/vZ8jPa1pTMTU2JS0hQ/36jfHniEhK4FhxMWrdyWr58OY8fP8bf359CT0/fx8XFqetMN3c6+0FRFIZ37kz3NAq4lDJatqIo2NnZsXr16hemnT59Ot3nZPS6mT2X9/n9/GybM1vu831r3OrUYc7w4S88r52zM/WqV+fgmTN8t3UrG/btY9777zO+f3/+vXmTI+fO8dFHH/H222/T8+mZsLi4OIpno+lNFFxynwzxSvn999/56aefePvtt4EnV5+sWLGC2Ph44En7+5U7dwBo4ejIsu3b1S+JZ80lrrVqsX7vXhRFITImhh07dtC4ceMc5dmwYQMA169f5/yNG9StVi3N+VrWr8/SrVtJSk5Ws9wKDSUyJobwx49xdnDA29sbW1tbLl26xN27d9HpdLRu3Zpx48YRHh7Ow4cPUy2zcePG7Nu3j3v37gGwbt06XF1dc7Qdually5ZpbuvzqpQrx70HD4h/WmgUMTdnUPv2TF62jLCwMODJF+fWrVu5efMmERERlClThkKFChESEsIff/yRap0//PAD8U/fBymbS9LNWb8+a37/XW0eiE9I4EIat952dHTk3LlzXL9+HQB/f/9U027cuMGRI0fUx86cOYOiKDRt2pT9+/dz/ekv/viEBCJjYnCsXp3zN25wJSgIgE1//kmNSpXSPIuSmb1796rbumnTJlxcXNKcr0mTJvx55gyXbt/+L+eVKwDcuHuXMq+9Rld3dz7o2pWzTx+/GhSEXcWKDGzfnk6dOnE2xZmwK1euYG9vn+28ouCRMxkic7GxWbrcNNsiIuDp6faMeHt7q5ewVqtWjaVLl1KvXj0Ahg4dyldffUX3SZOe9KA3MmJE165Ue/11xvXrx8wff8Rj7Fh0Oh3O9vZMHDiQ97t0YfqKFXj6+ABPOn4+35kvq8zMzOjduzcPHjxg2jvvpDr9n9L4/v2Z+9NPeI0bhxFgamrK+P79MdXp+HDhQmLj41HMzalRowZt27blyJEj6lUkycnJDB06FGtra/WLDqB69eqMHj2awYMHA1ChQgWmTZsGKebJC+PHj2fup5++sK3Pn9kwNzPDpUYNjp4/j1udOgCM6tWLFb/8Qv/+/YEnRYaTkxPNmzenf//+fPTRR3Tu3JmyZcumKgyHDh3KF198QefOnTE1NaVSpUosWrQow5yd3dx4GBlJv6dNCIqi8Fbr1tg/N05HqVKlmD59OsOGDaN48eK0b99enfbaa6/h5+fH3LlzmTlzJgkJCVSoUIFvvvmGypUrM336dD729SUpORmdsTGz33sPu4oVmTN8OGO+/prEpCRKFivG3Pffz9G+bty4MePHj+fWrVtUqVIFn6fv6edVrlyZucOHM2HpUmITEkhITKS+rS11qlXjl6NH2XbwIKYmJhgZGTH+6b7/4uefuXH3LjpjY4qVLcvnn38OQHR0NJcvX6ZRo0Y5yiwKFhkgLZuuXbuGj48PDx8+pHjx4vj6+r7Q+enAgQPMnz+fixcv0r9/f7UjVlbk9QBp58+fxyE7YyWcOJHzDPByN/PKrRw5zPDCvRIK8L7IaYa/L17k+4AA/EaNytMcadJChgxypLz6R+85UmRYu3Ytd+/eZWQ69x7J8BgiA6QVONJckk1TpkyhT58+/Prrr/Tp04fJkye/ME+FChWYMWMG77zzTh4kFOLVUd/WlhaOjkTLeBevDJ1Op17yLURmpMjIhrCwMM6dO4eHhwcAHh4enDt37oX230qVKlGjRg1MTKQ1Kj/7999/C+QdH3NbjxYtUnWSFVnz4YcfZussaW7p0aMHFhYWBl+veDXJt2A2BAcHY21trV5loNPpsLKyIjg4ONUlc7khMDAww+kNnl4m+TL++uuvFx4zMTFRbyqUmdz6gs3q+vSZQwsZtJJDCxm0kkMLGbSSI6sZ4uPj0zy25MYxC9I+bgntkiJDowzRrpjWh/78+fMG/3WuhbMBWsgA2sihhQygjRxayADayJHVDGZmZnq95X96xcqzPhlCW6S5JBtsbGwICQlRr7NPSkoiNDQUGxubPE4mhBBCaI8UGdlQqlQpHBwcCAgIACAgIAAHB4dcbyoRQggh8gNpLsmmzz77DB8fH/z8/ChWrBi+vr4ADBkyBG9vb2rXrs2JEycYNWoUkZGRKIrC9u3b+fzzz3FLcZvpV0lisoKJcTqXnr3EZX6JcfGZvgFlqPfU8vtQ7/1nzCDo/n0sS5UiLi6Ot956i4EDB2a4jN9//x0rKyvqPL3XxsWLF5k7d26qMUaEEHlDioxsqlatWqo7/j2T8oDm5OTE/v37DRlLr0yMjZh98n6uL9fHsXSW5pOh3v+T34d6B5g4YAAthg4lODgYDw8PdeTP9Pz+++/UqlVLLTJsbW0xNTXlyJEjNJIrvITIU/IJFK8UGeo9/w71/jwbGxuqVKnCtWvXWLFiBbVq1aLf08HffHx8qFWrFpUqVWL37t0cOnQIf39/3n77bTp37oyHhwf+/v40euutLG+vECL3SZEhXjky1PsT+W2o9+ddvnyZq1evYmdnx759+9Kcx83NjZYtW6YqQODJUOSff/45SJEhRJ6SIkO8cmSo9yfy21Dvz8xYuZIvt2+nUKFCTJs2TR1iPTtKly7N/fv3SUhMxFSaTITIM/LpE68cGeo97fU971Ub6v2ZZ30yUtLpdCQ/HdUVSHe482fi4+MxNTWVAkOIPCaXsIpXigz1/p/8NtR7RipWrKgONR4aGsrRo0fVaZaWlkQ8fW2fuXLlitpZWAiRd6TMF5onQ70XnKHe09OzZ0+8vb3p1KkTlStXVq8kAejUqRPjxo1j586dasfPP//8k3bt2ulj84QQ2SBDvWuMFod6z/A+GS8hMS4ek0JmubMwGer9P6/Q8Ob6GOo9Pj6eHj16sHz5cko+vYIoR7TwemglRzYyyFDvIiU5kyEylWGB8RIHLhPIvQOoeCWlHOo9t0ZiDQoKYtSoUU/uxPsyRYYQ4qVJkSFEDv377795HSFf6NGiRa4ur3LlylSuXDlXlymEyBnp+CmEEEIIvZAiQwghhBB6IUWGEEIIIfRCigwhhBBC6IV0/BSZik2MxdwknZ7/L3F1SGxMBLlzPYEQQggtkiJDZMrcxByjqbl/nwxlSua3aGnZsiVmZmbqzbjeeOMNhgwZQv369XM9z6vg7NmzrFixIteGe/9gwQJuP70b54WbN7G1tcXY2JjSpUvTunVr4uLiGDRoUK6sKy0xcXH0nT6dVRMnYmFuTv8ZMwi6fx/Lp2OuAEyZMiXD1/uPP/7gxIkTjB07Nt15HkdF8fPu3Qzx9FQfm/Ddd3Rxc8Mpg2HkcyI8PJxhw4axZs0aTOS25qKAk0+A0LxFixapt4jetWsXQ4cOZdmyZdStWzePk2VNYlISJk/HPXlZtWvXzrUCA+Drjz9W/2/Xty9r16797+ZiBvDjrl20a9gw1T0y0hq7JCOtWrWiVatWGc7zODqa7wMCUhUZnw8Zkv3AWVCyZEnq1q3Lli1b6Natm17WIcSrQooM8Upp27YtZ86cYdmyZSxatIj4+HgWLFjA8b17SUhMxLZCBT4bPJgi5uZEREczc9UqAq9cwcjYGCc7OyYPGkRUbCwzfviBs09v1NSpVy+GPv1S69+/PzVr1uTMmTPcuXOHAQMGYG1tzapVqwgNDeWTTz5Rh3q3s7NjxIgRHDx4kAcPHjDKy4t2zs5PpvXtyydvvcW+U6doYGfHux07Mmv1av69eZO4hARcatRgXL9+6IyN+WrDBgIOH6bQa69hZGTEypUrMTU1ZezYsVy+fBkTExOqVKnCwoULOXr0KL6+vmzcuBGAzZs3s2zZMuDJ+B7Tpk2jFLBx3z4CDh2iWJEiXLp9m6IWFiweOZIyxYtneV8vXryY6Ohoxo4dy8aNGwkICKBo0aL8+++/WFtbM2nSJObMmcONGzeoVasW8+bNw8jIiMjISGZ9912a2/q8dbt388P48Zlm2bx5M7/99htff/018GSQuubNm7N27VqOHTvG3r17WbRoEQDr169n5cqVAJgmJPDtmDFMW7GCiOhovMaNo3ChQqz97DP6z5jB4A4daFG/PvcfPWLK//7HzZAQUBTe8fCg89OmwJYtW+Ll5cWhQ4e4d+8egwcPpl+/fiQnJzNt2jSOHDmCmZkZFhYWrF27FgAPDw9mzZolRYYo8KTIEK+cunXrsnv3bgC+//57ihYtyvrp0wGY+9NPLN26lY979mTmjz9iYW7OllmzMDY2VgdI89u0iWRFYdvs2UTFxNDL1xc7Ozt1qPe7d++yatUq7t27R9u2bRk0aBBr167lzJkzjBgxQi0y4MnorWvXruXq1au81aMHTnZ26vglyYrCjxMnAk9OzTe0t+fzIUNITk5mjJ8fG/bupZ2LC8t27ODwkiWYu7oSGRmJubk5e/bs4fHjx+x4Olz6o0ePXtgPFy9eZN68eWzcuBErKyu+/PJLpk+fzpdPh3o/e/UqW2fPxqZUKSZ+9x2rdu3i4549c7zfz549y7Zt2yhbtizvvfceo0ePZtWqVRQuXJguXbpw+PBhXF1dmTVrVprb2rNly1TLCw4LIyYujtfLlEn1+LOh3p/53//+R7t27Zg1axbh4eGULFmS/fv3U7VqVcqXL8+xY8fUeY8ePcq3337LmjVrKFOmDFEHDmBibMzkQYPoNnEiW2bNSnPbZvzwA9XLl+frjz8m9MEDuk6cSI2OHdUzaLGxsfz888/cvn0bT09PunTpwo0bNzh8+DC//PILxsbGqV6jmjVrcuHCBaKjo7HI8R4X4tUnRYZ45aQcbmf37t1ERkby66ZNAMQnJmJfsSIAe06eZOOMGRg//QVdsmhRAA4HBjJ+wACMjIywtLCgY8eOHD58WC0y2rdvj7GxMdbW1hQvXpzWrVsDT744QkJCiIuLU8dG6NGjBwBVq1alRuXKnLp8mVYNGgDQxc3tv5x//82ZK1dY/rRoiI2Px7pkSSwLF6aKjQ2f+Pnhdvs2zZs3x9LSEnt7e65evcrUqVNxdnamefPmL+yHo0eP4u7ujtXTgcd69+6Nl5cXPC0y6tvaYvO0b0Pd6tU59HQU05yqX78+ZcuWBcDBwYHXX3+dok/3qb29PTdu3MDV1ZXdu3dzpkiRF7b1eXfDw9McUC695pJWrVoREBDAgAED2LRpE127dn1hnr179+Ll5UWZp4VLkSzeqvzwP//g07cvAFYlSuBerx5Hjx5Vi4wOHToAUL58eYoVK8bdu3epUKECSUlJTJgwARcXF1qkuHOpiYkJlpaW3Lt3j0pZSiBE/iRFhnjlnD17lurVqwNPCo4pU6bQ2NQ0y89XgOe7sRqlGLgp5eBKOp1O/Vv3tF9FYmJimgMwKYqSajkp+xkoioLfqFEvjEQKsG7qVP6+eJEjd+/StWtXvv/+e+zt7dmxYwdHjhxh//79LFiwgG3btmW4vucVSrFPdEZGJCUlpTtvVqS3X579/Wz5GW1rSuampsRlYZj3Z7p27crMmTPx9PTk2LFjzJkzJ5tbkLHn92VG74mkpCSKFi3K9u3bOXr0KIcPH2bevHls2rRJLXDi4+Mxz6XxWIR4Vcl9MsQr5ffff+enn37i7bffBp60l69YsYLY+HgAImNiuHLnDgAtHB1Ztn27eubjWXOJa61arN+7F0VRiIyJYceOHTRu3DhHeTZs2ADA9evXOX/jBnWrVUtzvpb167N061aSkpPVLLdCQ4mMiSH88WOcHRzw9vbG1taWS5cucffuXXQ6Ha1bt2bcuHGEh4fz8OHDVMts3Lgx+/bt4969ewCsW7cOV1fXHG1HbmrZsmWa2/q8KuXKce/BA+KzWGg4OTkRGRnJ/Pnzad26NYULF35hnhYtWrBlyxbu378PQFRsLPEJCVgWLkxsfDyJ6RRajWvW5OenTXD3Hj5k36lTuLi4ZJgnPDyc2NhYmjVrxpgxYyhatCi3bt0C4P79++h0OvUskxAFlZzJEJmKTYzN0uWm2V5uTATmhYtmOp+3t7d6CWu1atVYunQp9erVA2Do0KF89dVXdJ80CSMjI4yMjBjRtSvVXn+dcf36MfPHH/EYOxadToezvT0TBw7k/S5dmL5iBZ4+PsCTjp/NmjXL0TaYmZnRu3dvHjx4wLR33knz9D/A+P79mfvTT3iNG4cRYGpqyvj+/THV6fhw4UJi4+NRzM2pUaMGbdu25ciRI+pVJMnJyQwdOhRra2uuX7+uLrN69eqMHj2awYMHA1ChQgWmTZsGKebJC+PHj2fup5++sK3Pn9kwNzPDpUYNjp4/j1udOurjz/fJ8Pb2Vq8e6dy5MwsXLmT16tVprtvZ2ZmhQ4fy9ttvY2RkhFlCAt+MGUPp117D09UVTx8fXitShLWffZbqeRMHDmTysmVP3hOKwpjevdWzZekJDg5m0qRJJCYmkpSURLNmzdT35YEDB2jTpk2GZ5qEKAiMlJQN3CLPxcXFERgYSK1atdI8JZ/KyxzA0nnZz58/j4ODQ9aX8xJDvQO5N9T7y+TIYQY7Ozv+/vvv/y75LMD7IqcZ/r54ke8DAvAbNSpPc6TpJTL069ePqVOnUq1atQL3vsjwGPKyRVcGX1fZOnYKg5HmEiFEnqlva0sLR0eiY2PzOkquCQ8Pp1evXk8KDCEKOGkuESKH/v3337yOkC/0SHFVRn5QsmRJPFPc9EuIgkzOZIgXSAuaECIn5NghnidFhkjF3NycsLAwOVgIIbJFURTCwsLksl2RijSXiFTKly/P7du31csiM/X0UsEcO3/+5Z6fGzm0kEErObSQQSs5tJBBKzmymMHc3Jzy5cvnfD0i35GrSzQmr68uyTY99hY3WA4tZNBKDi1k0EoOLWTQSg4tZMgkh1xdok3SXCKEEEIIvZAiI5uuXbtGr169aNeuHb169Up1c6RnkpKSmDp1Kq1bt6ZNmzb4+/sbPqgQQgiRx6TIyKYpU6bQp08ffv31V/r06cPkyZNfmGfbtm3cvHmTXbt28fPPP7N48WJu376dB2mFEEKIvCMdP7MhLCyMc+fOsXz5cgA8PDyYPn26Ovz0Mzt27KBHjx4YGxtTsmRJWrduzc6dO3n33XczXcezLjLxT8fiyJCNTc42BCAuLufPza0MWsmhhQxayaGFDFrJoYUMWsmhhQyZ5Hh2zJRuhtoiHT+zITAwkLFjx7I9xbgKHTp0YO7cudSsWVN9zNPTk88//5w6T8dj+O677wgJCWHixImZriMiIoKLFy/mfnghhCgAbG1tKVo08zGRhGHImQyNKVKkCLa2tpiamsrgSkIIkUWKopCQkPDfWEJCE6TIyAYbGxtCQkJISkpCp9ORlJREaGgoNs+dArSxsSEoKEg9kxEcHEy5cuWytA5jY2OpwoUQIgfkRmDaIx0/s6FUqVI4ODgQEBAAQEBAAA4ODqn6YwC0b98ef39/kpOTCQ8P5/fff6ddu3Z5EVkIIYTIM9InI5uuXLmCj48Pjx8/plixYvj6+lK1alWGDBmCt7c3tWvXJikpiWnTpnHw4EEAhgwZQq9evfI4uRBCCGFYUmQIIYQQQi+kuUQIIYQQeiFFhhBCCCH0QooMIYQQQuiFFBlCCCGE0AspMoQQQgihF1JkCCGEEEIvpMgQQgghhF5IkZHPPbshmCHEx8cTEhLywuOXLl0yWAaAixcvquu8fv06K1as4NChQwbN8LzJkyfn6foBHj16xIkTJwgLCzPYOsPDw1ONKLxlyxZmzJiBv7+/wTIA7Nmzh4SEBIOu83nJycns3LmTkydPArBr1y6mT5/O2rVrSU5ONmiWkJAQVqxYweeff46vry/r168nLrdGWn1JhjxmCf2Tm3Hlc82bN2fv3r16X8+BAwf4+OOPAahQoQILFiygUqVKAHTp0oVNmzbpPQPAjz/+yPLly0lMTOSdd95hy5Yt1K5dm6NHj9K/f3/69u2r9wxz5sx54TF/f3969OgBwKeffqr3DADTp09n0qRJAJw6dYr333+fsmXLEhQUxNy5c3Fzc9N7hk6dOrFmzRosLS1ZsmQJ+/fvp1WrVhw+fBhbW1vGjh2r9wwADg4OvPbaa3h6etKtWzfs7e0Nst6Upk2bRmBgIImJiTRt2pRjx46p+6Jq1apZGqU5N2zdupUFCxZgb2/PyZMnady4MVFRUVy6dIlvvvkGOzs7g+RIj6GOWcIwZIC0fCCtLzV4MiphRESEQTIsWLCAH3/8EXt7ezZt2sTbb7+Nn58f9vb2GLKO9ff3JyAggOjoaFq1asWvv/5K2bJlCQ8PZ/DgwQYpMtasWUPr1q2pXLlyqsctLCz0vu6U/v77b/X/ixcvZt68ebi6unL+/HkmT55skCJDURQsLS0B+O233/jxxx8pUqQIAwcOpGvXrgYrMuzs7Jg9ezbr169n0KBBlCtXjm7duuHp6UmxYsUMkuHIkSNs27aN2NhY3Nzc2L9/P5aWluq+MJRvv/2WDRs2ULJkSW7dusXMmTNZunQphw8fZtq0aaxevVrvGbRwzBKGIc0l+cCPP/5IoUKFsLCwSPWvSJEiBhsuPikpSf112KVLF2bPns3w4cM5c+aMQYesNzY2xsLCgtKlS1OhQgXKli0LQMmSJQ2WY+PGjYSEhFCkSBE++OADRowYQdGiRRkxYgQjRowwSIbn3b9/H1dXV+DJr/qUTRj6Fh4eDjwpsgoVKgSAqakpSUlJBstgZGSEvb09EydO5M8//+Tdd99lz549uLu7M3r0aINkMDExQafTYWFhQeHChdXiy8zMDGNjwx2KdTqdOqhjhQoVCA4OBqBx48Y8ePDAIBm0cMwShiFnMvIBW1tb2rVrl+YpYEO1fScmJhIXF6d+iTg7OzN//nw++ugjg7b1pmzbHjVqVKpphmqTr1q1Kj/88ANLly5lwIABfPbZZ3ly4AwJCWHOnDkoisKjR49ISkpCp9MBGKwPwPDhwxkwYACDBw/GyckJb29v2rVrx8GDB2nWrJlBMgCpzqaZmprSoUMHOnTowN27d9m8ebNBMtjY2DBnzhyioqKoVq0aM2fOxNPTkz///JPSpUsbJANA+fLlWbJkCW5ubmzfvp3q1asDT34oGKrw08IxSxiGnMnIB0aNGkWRIkXSnDZ//nyDZOjQoQMnTpxI9ZijoyMLFy6kXLlyBskAMGjQIKKiogBo2bKl+vjVq1dp0qSJwXIYGxszbNgwJkyYwLhx44iOjjbYup/p06eP+uuwe/fuPHz4EHhSfNSsWdMgGTp06MCsWbM4dOgQ+/bt49atW/zyyy80a9bMYE0lQLr9DMqWLcuwYcMMkmHWrFkkJiZibm7O4sWLqVq1KuPHj+fs2bNMnTrVIBngSd+Qy5cv4+PjQ3h4OOPGjQMgIiKCCRMmGCSDFo5ZwjCk46cQepaYmMi9e/ewsbHJ6yhCCGFQ0lySTwQFBbFz5061fdXGxoa2bdtSvnz5ApVBKzm0kEErObSQQSs50srQrl07Xn/9dYNlSC+HFvZFXrwvhH5Jc0k+4O/vz1tvvcWdO3ewtrbG2tqaO3fu0K9fP4O1b2ohg1ZyaCGDVnJoIYNWcqSXoW/fvrIv8uh9IQxAEa+8tm3bKmFhYS88HhYWprRp06bAZNBKDi1k0EoOLWTQSg4tZNBKDi1kEIYhZzLygeTkZPWStJRKlChhsHtUaCGDVnJoIYNWcmghg1ZyaCGDVnJoIYMwDOmTkQ80bdqUd999l549e6pXcgQFBbFu3TqDXVGhhQxayaGFDFrJoYUMWsmhhQxayaGFDMIw5OqSfCA5OZmtW7fyyy+/EBQUBEC5cuVo3749Xl5eBrnRjxYyaCWHFjJoJYcWMmglhxYyaCWHFjIIw5AiQwghhBB6Ic0l+YQWLgfTQgat5NBCBq3k0EIGreTQQgYt5UjLP//8Y7CbxQn9k3NS+YAWLgfTQgat5NBCBq3k0EIGreTQQgYt5UjPwoUL8zqCyE15cUmLyF1auBxMCxm0kkMLGbSSQwsZtJJDCxm0lENRFCU8PFw5d+6ccu7cOSU8PNyg6xaGIc0l+YAWLgfTQgat5NBCBq3k0EIGreTQQgat5Lh58yaTJk3i3LlzWFlZARAaGkqNGjWYNm0alSpVMkgOoX9SZOQDWrgcTAsZtJJDCxm0kkMLGbSSQwsZtJLj008/pU+fPixfvly9kiQ5OZlt27bx6aef8vPPPxskh9A/ubokH9DC5WBayKCVHFrIoJUcWsiglRxayKCVHO3bt2fnzp3ZniZePVJkCCGEMKjevXvTr18/OnbsiJGREQCKorBt2zZWrVrFunXr8jihyC1ydUk+988//+R1BE1kAG3k0EIG0EYOLWQAbeTQQgYwXI7Zs2fj7++Pi4sLnp6eeHp64uLiwvr165k9e7ZBMgjDkCIjn9PC5WBayADayKGFDKCNHFrIANrIoYUMYLgclStX5ocffmDnzp3Mnj2b2bNns3PnTlauXEnVqlUNkkEYhjSX5CMPHjzg7t27AJQtW5YSJUoUyAxayaGFDFrJoYUMWsmhhQxayiHyN7m6JB/QwuVgWsiglRxayKCVHFrIoJUcWsigpRyigDD8rTlEbuvVq5eyZcsWJSkpSX0sKSlJ2bx5s9KzZ88Ck0ErObSQQSs5tJBBKzm0kEFLOUTBIH0y8oGHDx/SqVOnVJeeGRsb4+XlxaNHjwpMBq3k0EIGreTQQgat5NBCBi3lEAWDFBn5QPHixQkICEh1tz5FUdi6dSvFihUrMBm0kkMLGbSSQwsZtJJDCxm0lEMUDNLxMx+4fv06U6ZM4fz581hbWwMQEhKCvb09n332mUF6a2shg1ZyaCGDVnJoIYNWcmghg5ZyiIJBiox8JDw8PNXQzWmNT1AQMmglhxYyaCWHFjJoJYcWMmgph8jfpMgQQgghhF5InwwhhBBC6IUUGUIIIYTQCykyhMgnOnbsyNGjR/M6hhBCqOSOn0K8IhwdHdX/x8TEYGZmhk6nA2Dq1Kls377dIDkeP37MrFmz2L9/P9HR0VhZWdGtWzeGDh0KgJ2dHbt27ZI7RwohpMgQ4lVx8uRJ9f8tW7ZkxowZuLq6GjzHrFmziI6OZseOHRQtWpRr165x6dIlg+cQQmifNJcIkU+0bNmSQ4cOAbB48WK8vb0ZM2YMjo6OeHp6cu3aNb799lsaN26Mu7s7Bw4cUJ8bERHB+PHjadq0KW5ubixYsICkpKQ013P27Fk8PT157bXXMDY2plq1arRv3x6Avn37AuDl5YWjoyM7duwAYM+ePXh5eeHk5ETv3r25cOFCqtzffvstHTp0oGHDhowbN464uDjgyWWW7733Hk5OTjg7O9OnTx+Sk5Nzf+cJIfRCigwh8qlnX+zHjx/HwcGBd955h+TkZPbv388HH3zA5MmT1XnHjh2LiYkJu3btYvPmzRw8eBB/f/80l1u3bl0WLFjAhg0buH79eqppq1evBmDLli2cPHmSDh068M8//zB+/HimTZvG0aNH6dWrF++//z7x8fHq87Zt28ayZcv47bffuHbtGn5+fgAsX74ca2trDh8+zMGDBxk1ahRGRka5vKeEEPoiRYYQ+ZSTkxNubm6YmJjQvn17Hjx4wNChQzE1NaVDhw7cuXOHx48fc//+ffbv38/48eOxsLCgVKlSDBo0KN0+HpMmTcLT05PVq1fTsWNH2rRpw759+9LNsW7dOnr16kXdunXR6XR06dIFU1NTTp06pc7Tt29fbGxsKF68OMOHD1fXbWJiwr179wgKCsLU1BQnJycpMoR4hUifDCHyqVKlSqn/Nzc3p0SJEmpHUXNzcwCio6MJDQ0lMTGRpk2bqvMnJydjY2OT5nLNzc0ZNmwYw4YNIzIykqVLlzJy5Ej27NlD8eLFX5g/KCiIzZs3s2rVKvWxhIQEQkND1b9TrqtcuXLqtHfeeYevvvqKwYMHA9CrVy+1g6kQQvukyBCigCtbtixmZmYcOXIEE5PsHRIsLS157733+Pbbb7l9+3aaRYaNjQ3Dhg1j+PDh6S7n2e2t4UlRYmVlpS7fx8cHHx8fLl26xIABA6hduzaNGzfOVk4hRN6Q5hIhCjgrKyuaNGnC7NmziYyMJDk5mZs3b3Ls2LE05//66685c+YM8fHxxMXFsXLlSooVK0aVKlUAKF26NLdu3VLn79GjB2vXruX06dMoikJ0dDR79+4lMjJSnWfNmjXcvXuXhw8fqp1A4Um/khs3bqAoCpaWluh0ulRDlAshtE3OZAghmDNnDvPmzaNDhw5ERUVRoUIFhgwZkua8RkZGjB8/nqCgIExMTLCzs+Pbb7+lSJEiAIwYMQIfHx9iY2OZNm0aHTp0YPr06UybNo0bN25gbm5O/fr1cXJyUpfp4eHB4MGDCQ0NpVWrVupZjxs3bjB9+nTCw8MpVqwYb731Fi4uLvrfIUKIXCEDpAkh8lRe3vNDCKFfct5RCCGEEHohRYYQQggh9EKaS4QQQgihF3ImQwghhBB6IUWGEEIIIfRCigwhhBBC6IUUGUIIIYTQCykyhBBCCKEX/wdoQzZucdAZSgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# create stacked bar chart for monthly temperatures\n", + "for i in range(1,len(all_data_frames)):\n", + " df = pd.DataFrame({'Decompression Time (Cache decompress)':all_data_frames[i]['Decompression Time (Cache decompress)'],'Decompression Time (Put)':all_data_frames[i]['Decompression Time (Put)'],'Decompression Time (Evictions)':all_data_frames[i]['Decompression Time (Evictions)']})\n", + " df.plot(kind='bar', stacked=True, color=['red', 'skyblue', 'green'])\n", + " plt.ylabel('Time (s)')\n", + " plt.title('Decompression Time Overhead Breakdown when not found in cache with Cache Size '+str(cache_size[i-1]))\n", + " # ax = plt.gca()\n", + " # ax.set_ylim([ymin, ymax])\n", + " plt.savefig('Decomp_time_cache_size_'+str(cache_size[i-1])+'.png')\n", + " all_df.append(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "9d81a59c-34c6-49bd-bac7-2ebb696b45c2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Cache invalidates')" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cache_size = [1,2,4,8,16]\n", + "ax = all_data_frames[1].plot(y='Cache Invalidates',label='Cache Size 1')\n", + "for i in range(2,len(all_data_frames)):\n", + " all_data_frames[i].plot(ax=ax,y='Cache Invalidates',label='Cache Size '+str(cache_size[i-1]))\n", + "plt.xlabel('Time step (s)')\n", + "plt.ylabel('Cache invalidates')" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "efb56585-bc53-42d6-9935-7b46fb990c93", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "7ff72107-351a-4761-8cc1-651a6bb28d49", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "cdcdec70-3788-45aa-a740-f779de102948", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "979f929e-b346-40a1-b67f-c0bf5210e384", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "0fb8668c-66fd-402e-96c0-094bda90cad3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8872da72-9e14-439d-8a2c-aa6f2f1aa3e8", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pySDC/projects/compression/order.py b/pySDC/projects/compression/order.py index d93207a05a..1a5b5b60f1 100644 --- a/pySDC/projects/compression/order.py +++ b/pySDC/projects/compression/order.py @@ -9,33 +9,27 @@ from pySDC.projects.compression.compression_convergence_controller import Compression -MACHINEPRECISION = 1e-8 # generous tolerance below which we ascribe errors to floating point rounding errors rather than compression +MACHINEPRECISION = ( + 1e-8 # generous tolerance below which we ascribe errors to floating point rounding errors rather than compression +) LOGGER_LEVEL = 30 -def single_run( - problem, description=None, thresh=1e-10, Tend=2e-1, useMPI=False, num_procs=1 -): +def single_run(problem, description=None, thresh=1e-10, Tend=2e-1, useMPI=False, num_procs=1): description = {} if description is None else description compressor_args = {} compressor_args["compressor_config"] = {"pressio:abs": thresh} if thresh > 0: - description["convergence_controllers"] = { - Compression: {"compressor_args": compressor_args} - } + description["convergence_controllers"] = {Compression: {"compressor_args": compressor_args}} controller_params = { "mssdc_jac": False, "logger_level": LOGGER_LEVEL, } - error_hook = ( - error_hooks.LogGlobalErrorPostRunMPI - if useMPI - else error_hooks.LogGlobalErrorPostRun - ) + error_hook = error_hooks.LogGlobalErrorPostRunMPI if useMPI else error_hooks.LogGlobalErrorPostRun stats, _, _ = problem( custom_description=description, @@ -100,20 +94,14 @@ def multiple_runs( def get_order(values, errors, thresh=1e-16, expected_order=None): values = np.array(values) idx = np.argsort(values) - local_orders = np.log(errors[idx][1:] / errors[idx][:-1]) / np.log( - values[idx][1:] / values[idx][:-1] - ) + local_orders = np.log(errors[idx][1:] / errors[idx][:-1]) / np.log(values[idx][1:] / values[idx][:-1]) order = np.mean(local_orders[errors[idx][1:] > max([thresh, MACHINEPRECISION])]) if expected_order is not None: - assert np.isclose( - order, expected_order, atol=0.5 - ), f"Expected order {expected_order}, but got {order:.2f}!" + assert np.isclose(order, expected_order, atol=0.5), f"Expected order {expected_order}, but got {order:.2f}!" return order -def plot_order( - values, errors, ax, thresh=1e-16, color="black", expected_order=None, **kwargs -): +def plot_order(values, errors, ax, thresh=1e-16, color="black", expected_order=None, **kwargs): values = np.array(values) order = get_order(values, errors, thresh=thresh, expected_order=expected_order) ax.scatter(values, errors, color=color, **kwargs) diff --git a/pySDC/projects/compression/run_serial_examples.py b/pySDC/projects/compression/run_serial_examples.py new file mode 100644 index 0000000000..24e4552b9f --- /dev/null +++ b/pySDC/projects/compression/run_serial_examples.py @@ -0,0 +1,290 @@ +import numpy as np + +from pySDC.helpers.stats_helper import get_sorted + +from pySDC.implementations.controller_classes.controller_nonMPI import controller_nonMPI +from pySDC.implementations.problem_classes.HeatEquation_ND_FD import heatNd_forced +from pySDC.implementations.problem_classes.AdvectionEquation_ND_FD import advectionNd +from pySDC.implementations.problem_classes.Auzinger_implicit import auzinger +from pySDC.implementations.sweeper_classes.imex_1st_order import imex_1st_order +from pySDC.implementations.sweeper_classes.generic_implicit import generic_implicit +from pySDC.implementations.transfer_classes.TransferMesh import mesh_to_mesh +from pySDC.implementations.transfer_classes.TransferMesh_NoCoarse import ( + mesh_to_mesh as mesh_to_mesh_nc, +) +from pySDC.implementations.convergence_controller_classes.check_iteration_estimator import ( + CheckIterationEstimatorNonMPI, +) +from pySDC.playgrounds.compression.HookClass_error_output import error_output + +# from pySDC.implementations.hook + +from pySDC.projects.compression.sweeper_imex_compression import ( + imex_1st_order_compression, +) + + +def setup_diffusion(dt=None, ndim=None, ml=False): + # initialize level parameters + level_params = dict() + level_params["restol"] = 1e-10 + level_params["dt"] = dt # time-step size + level_params["nsweeps"] = 1 + + # initialize sweeper parameters + sweeper_params = dict() + sweeper_params["quad_type"] = "RADAU-RIGHT" + sweeper_params["num_nodes"] = 3 + sweeper_params["QI"] = ["LU"] # For the IMEX sweeper, the LU-trick can be activated for the implicit part + # sweeper_params['initial_guess'] = 'zero' + + # initialize problem parameters + problem_params = dict() + problem_params["order"] = 8 # order of accuracy for FD discretization in space + problem_params["nu"] = 0.1 # diffusion coefficient + problem_params["bc"] = "periodic" # boundary conditions + problem_params["freq"] = tuple(2 for _ in range(ndim)) # frequencies + if ml: + problem_params["nvars"] = [ + tuple(64 for _ in range(ndim)), + tuple(32 for _ in range(ndim)), + ] # number of dofs + else: + problem_params["nvars"] = tuple(64 for _ in range(ndim)) # number of dofs + problem_params["liniter"] = 10 # number of CG iterations + + # initialize step parameters + step_params = dict() + step_params["maxiter"] = 50 + + # initialize space transfer parameters + space_transfer_params = dict() + space_transfer_params["rorder"] = 2 + space_transfer_params["iorder"] = 6 + space_transfer_params["periodic"] = True + + # setup the iteration estimator + convergence_controllers = dict() + convergence_controllers[CheckIterationEstimatorNonMPI] = {"errtol": 1e-7} + + # initialize controller parameters + controller_params = dict() + controller_params["logger_level"] = 20 + # controller_params['hook_class'] = error_output + + # fill description dictionary for easy step instantiation + description = dict() + description["problem_class"] = heatNd_forced # pass problem class + description["problem_params"] = problem_params # pass problem parameters + description["sweeper_class"] = imex_1st_order_compression # pass sweeper (see part B) + description["sweeper_params"] = sweeper_params # pass sweeper parameters + description["level_params"] = level_params # pass level parameters + description["step_params"] = step_params # pass step parameters + description["space_transfer_class"] = mesh_to_mesh # pass spatial transfer class + # description['space_transfer_class'] = mesh_to_mesh_fft # pass spatial transfer class + description["space_transfer_params"] = space_transfer_params # pass paramters for spatial transfer + description["convergence_controllers"] = convergence_controllers + + return description, controller_params + + +def setup_advection(dt=None, ndim=None, ml=False): + # initialize level parameters + level_params = dict() + level_params["restol"] = 1e-10 + level_params["dt"] = dt # time-step size + level_params["nsweeps"] = 1 + + # initialize sweeper parameters + sweeper_params = dict() + sweeper_params["quad_type"] = "RADAU-RIGHT" + sweeper_params["num_nodes"] = 3 + sweeper_params["QI"] = ["LU"] # For the IMEX sweeper, the LU-trick can be activated for the implicit part + # sweeper_params['initial_guess'] = 'zero' + + # initialize problem parameters + problem_params = dict() + problem_params["order"] = 6 # order of accuracy for FD discretization in space + problem_params["stencil_type"] = "center" # order of accuracy for FD discretization in space + problem_params["bc"] = "periodic" # boundary conditions + problem_params["c"] = 0.1 # diffusion coefficient + problem_params["freq"] = tuple(2 for _ in range(ndim)) # frequencies + if ml: + problem_params["nvars"] = [ + tuple(64 for _ in range(ndim)), + tuple(32 for _ in range(ndim)), + ] # number of dofs + else: + problem_params["nvars"] = tuple(64 for _ in range(ndim)) # number of dofs + problem_params["liniter"] = 10 # number of GMRES iterations + + # initialize step parameters + step_params = dict() + step_params["maxiter"] = 50 + + # initialize space transfer parameters + space_transfer_params = dict() + space_transfer_params["rorder"] = 2 + space_transfer_params["iorder"] = 6 + space_transfer_params["periodic"] = True + + # setup the iteration estimator + convergence_controllers = dict() + convergence_controllers[CheckIterationEstimatorNonMPI] = {"errtol": 1e-7} + + # initialize controller parameters + controller_params = dict() + controller_params["logger_level"] = 30 + controller_params["hook_class"] = error_output + + # fill description dictionary for easy step instantiation + description = dict() + description["problem_class"] = advectionNd + description["problem_params"] = problem_params # pass problem parameters + description["sweeper_class"] = generic_implicit + description["sweeper_params"] = sweeper_params # pass sweeper parameters + description["level_params"] = level_params # pass level parameters + description["step_params"] = step_params # pass step parameters + description["space_transfer_class"] = mesh_to_mesh # pass spatial transfer class + # description['space_transfer_class'] = mesh_to_mesh_fft # pass spatial transfer class + description["space_transfer_params"] = space_transfer_params # pass paramters for spatial transfer + description["convergence_controllers"] = convergence_controllers + + return description, controller_params + + +def setup_auzinger(dt=None, ml=False): + # initialize level parameters + level_params = dict() + level_params["restol"] = 1e-10 + level_params["dt"] = dt # time-step size + level_params["nsweeps"] = 1 + + # initialize sweeper parameters + sweeper_params = dict() + sweeper_params["quad_type"] = "RADAU-RIGHT" + if ml: + sweeper_params["num_nodes"] = [3, 2] + else: + sweeper_params["num_nodes"] = 3 + sweeper_params["QI"] = ["LU"] # For the IMEX sweeper, the LU-trick can be activated for the implicit part + # sweeper_params['initial_guess'] = 'zero' + + # initialize problem parameters + problem_params = dict() + problem_params["newton_tol"] = 1e-12 + problem_params["newton_maxiter"] = 10 + + # initialize step parameters + step_params = dict() + step_params["maxiter"] = 50 + + # setup the iteration estimator + convergence_controllers = dict() + convergence_controllers[CheckIterationEstimatorNonMPI] = {"errtol": 1e-7} + + # initialize controller parameters + controller_params = dict() + controller_params["logger_level"] = 30 + controller_params["hook_class"] = error_output + + # fill description dictionary for easy step instantiation + description = dict() + description["problem_class"] = auzinger + description["problem_params"] = problem_params # pass problem parameters + description["sweeper_class"] = generic_implicit + description["sweeper_params"] = sweeper_params # pass sweeper parameters + description["level_params"] = level_params # pass level parameters + description["step_params"] = step_params # pass step parameters + description["space_transfer_class"] = mesh_to_mesh_nc # pass spatial transfer class + description["convergence_controllers"] = convergence_controllers + + return description, controller_params + + +def run_simulations(type=None, ndim_list=None, Tend=None, nsteps_list=None, ml=False, nprocs=None): + """ + A simple test program to do SDC runs for the heat equation in various dimensions + """ + + t0 = None + dt = None + description = None + controller_params = None + + for ndim in ndim_list: + for nsteps in nsteps_list: + if type == "diffusion": + # set time parameters + t0 = 0.0 + dt = (Tend - t0) / nsteps + description, controller_params = setup_diffusion(dt, ndim, ml) + elif type == "advection": + # set time parameters + t0 = 0.0 + dt = (Tend - t0) / nsteps + description, controller_params = setup_advection(dt, ndim, ml) + elif type == "auzinger": + assert ndim == 1 + # set time parameters + t0 = 0.0 + dt = (Tend - t0) / nsteps + description, controller_params = setup_auzinger(dt, ml) + + print(f"Running {type} in {ndim} dimensions with time-step size {dt}...") + print() + + # Warning: this is black magic used to run an 'exact' collocation solver for each step within the hooks + description["step_params"]["description"] = description + description["step_params"]["controller_params"] = controller_params + + # instantiate controller + controller = controller_nonMPI( + num_procs=nprocs, + controller_params=controller_params, + description=description, + ) + + # get initial values on finest level + P = controller.MS[0].levels[0].prob + uinit = P.u_exact(t0) + + # call main function to get things done... + uend, stats = controller.run(u0=uinit, t0=t0, Tend=Tend) + + # filter statistics by type (number of iterations) + iter_counts = get_sorted(stats, type="niter", sortby="time") + + niters = np.array([item[1] for item in iter_counts]) + out = f" Mean number of iterations: {np.mean(niters):4.2f}" + print(out) + + # filter statistics by type (error after time-step) + PDE_errors = get_sorted(stats, type="PDE_error_after_step", sortby="time") + coll_errors = get_sorted(stats, type="coll_error_after_step", sortby="time") + for iters, PDE_err, coll_err in zip(iter_counts, PDE_errors, coll_errors): + out = ( + f" Errors after step {PDE_err[0]:8.4f} with {iters[1]} iterations: " + f"{PDE_err[1]:8.4e} / {coll_err[1]:8.4e}" + ) + print(out) + print() + + # filter statistics by type (error after time-step) + timing = get_sorted(stats, type="timing_run", sortby="time") + out = f"...done, took {timing[0][1]} seconds!" + print(out) + + print() + print("-----------------------------------------------------------------------------") + + +if __name__ == "__main__": + run_simulations(type="diffusion", ndim_list=[1], Tend=1.0, nsteps_list=[8], ml=False, nprocs=1) + # run_simulations(type='diffusion', ndim_list=[1], Tend=1.0, nsteps_list=[8], ml=True, nprocs=1) + + # run_simulations(type='advection', ndim_list=[1], Tend=1.0, nsteps_list=[8], ml=False, nprocs=1) + # run_simulations(type='advection', ndim_list=[1], Tend=1.0, nsteps_list=[8], ml=True, nprocs=1) + + # run_simulations(type='auzinger', ndim_list=[1], Tend=1.0, nsteps_list=[8], ml=False, nprocs=1) + # run_simulations(type='auzinger', ndim_list=[1], Tend=1.0, nsteps_list=[8], ml=True, nprocs=1) diff --git a/pySDC/projects/compression/sweeper_imex_compression.py b/pySDC/projects/compression/sweeper_imex_compression.py new file mode 100644 index 0000000000..543e711e3d --- /dev/null +++ b/pySDC/projects/compression/sweeper_imex_compression.py @@ -0,0 +1,185 @@ +import numpy as np +from pySDC.projects.compression.CRAM_Manager import CRAM_Manager +from pySDC.implementations.sweeper_classes.imex_1st_order import imex_1st_order + + +class imex_1st_order_compression(imex_1st_order): + """ + Custom sweeper class, implements Sweeper.py + + First-order IMEX sweeper using implicit/explicit Euler as base integrator + + Attributes: + QI: implicit Euler integration matrix + QE: explicit Euler integration matrix + """ + + def __init__(self, params): + """ + Initialization routine for the custom sweeper + + Args: + params: parameters for the sweeper + """ + + # call parent's initialization routine + super().__init__(params) + + # Instantiate CRAM_Manager class + self.manager = CRAM_Manager("ABS", "sz", 100) + self.manager_register = False + + def predict(self): + super().predict() + # Register all the variables + if self.manager_register == False: + self.manager_register = True + self.mgr_list = ["u", "fi", "fe"] + for i in self.mgr_list: + self.manager.registerVar( + i, + self.level.prob.init, + self.level.prob.init[2], + numVectors=self.coll.num_nodes + 1, + errBoundMode="ABS", + compType="sz3", + errBound=1e-5, + ) + # TODO: remove dtype, edit it + + # IMEX integration matrices + + def integrate(self): + """ + Integrates the right-hand side (here impl + expl) + + Returns: + list of dtype_u: containing the integral as values + """ + + # get current level and problem description + L = self.level + + me = [] + + # integrate RHS over all collocation nodes + for m in range(1, self.coll.num_nodes + 1): + me.append(L.dt * self.coll.Qmat[m, 1] * (L.f[1].impl + L.f[1].expl)) + # new instance of dtype_u, initialize values with 0 + for j in range(2, self.coll.num_nodes + 1): + me[m - 1] += L.dt * self.coll.Qmat[m, j] * (L.f[j].impl + L.f[j].expl) + + return me + + def update_nodes(self): + """ + Update the u- and f-values at the collocation nodes -> corresponds to a single sweep over all nodes + + Returns: + None + """ + + # get current level and problem description + L = self.level + P = L.prob + + # only if the level has been touched before + assert L.status.unlocked + + # get number of collocation nodes for easier access + M = self.coll.num_nodes + + # gather all terms which are known already (e.g. from the previous iteration) + # this corresponds to u0 + QF(u^k) - QIFI(u^k) - QEFE(u^k) + tau + + # get QF(u^k) + integral = self.integrate() + for jj in range(M + 1): + self.manager.compress(L.f[jj].impl, "fi", jj) + self.manager.compress(L.f[jj].expl, "fe", jj) + self.manager.compress(L.u[jj], "u", jj) + + u_zero = self.manager.decompress("u", 0) + + for m in range(M): + # subtract QIFI(u^k)_m + QEFE(u^k)_m + for j in range(1, M + 1): + f_impl = self.manager.decompress("fi", j) + f_expl = self.manager.decompress("fe", j) + integral[m] -= L.dt * (self.QI[m + 1, j] * f_impl + self.QE[m + 1, j] * f_expl) + # add initial value + integral[m] += u_zero + # add tau if associated + if L.tau[m] is not None: + integral[m] += L.tau[m] + + # do the sweep + for m in range(0, M): + # build rhs, consisting of the known values from above and new values from previous nodes (at k+1) + rhs = P.dtype_u(integral[m]) + for j in range(1, m + 1): + f_impl = self.manager.decompress("fi", j) + f_expl = self.manager.decompress("fe", j) + rhs += L.dt * (self.QI[m + 1, j] * f_impl + self.QE[m + 1, j] * f_expl) + + # implicit solve with prefactor stemming from QI + u_prev = self.manager.decompress("u", m + 1) + u_sol = P.solve_system( + rhs, + L.dt * self.QI[m + 1, m + 1], + u_prev, + L.time + L.dt * self.coll.nodes[m], + ) + # update function values + # L.f[m+1].impl = self.manager.decompress('fi',m+1) + # L.f[m+1].expl = self.manager.decompress('fe',m+1) + f_sol = P.eval_f(u_sol, L.time + L.dt * self.coll.nodes[m]) + + self.manager.compress(u_sol, "u", m + 1) + self.manager.compress(f_sol.impl, "fi", m + 1) + self.manager.compress(f_sol.expl, "fe", m + 1) + # L.u[m+1][:] = self.manager.decompress('u',m+1) + # print(m+1,abs(L.u[m+1]-u_sol), abs(L.u[m+1])) + # self.manager.compress(L.f[m + 1].impl,'fi',m+1) + # self.manager.compress(L.f[m + 1].expl,'fe',m+1) + + # indicate presence of new values at this level + L.status.updated = True + for m in range(M + 1): + # self.manager.compress(L.u[m + 1],'u',m+1) + # self.manager.compress(L.f[m + 1].impl,'fi',m+1) + # self.manager.compress(L.f[m + 1].expl,'fe',m+1) + L.u[m] = self.manager.decompress("u", m) + L.f[m].impl[:] = self.manager.decompress("fi", m) + L.f[m].expl[:] = self.manager.decompress("fe", m) + + return None + + def compute_end_point(self): + """ + Compute u at the right point of the interval + + The value uend computed here is a full evaluation of the Picard formulation unless do_full_update==False + + Returns: + None + """ + + # get current level and problem description + L = self.level + P = L.prob + + # check if Mth node is equal to right point and do_coll_update is false, perform a simple copy + if self.coll.right_is_node and not self.params.do_coll_update: + # a copy is sufficient + L.uend = P.dtype_u(L.u[-1]) + else: + # start with u0 and add integral over the full interval (using coll.weights) + L.uend = P.dtype_u(L.u[0]) + for m in range(self.coll.num_nodes): + L.uend += L.dt * self.coll.weights[m] * (L.f[m + 1].impl + L.f[m + 1].expl) + # add up tau correction of the full interval (last entry) + if L.tau[-1] is not None: + L.uend += L.tau[-1] + + return None diff --git a/pySDC/projects/compression/test.py b/pySDC/projects/compression/test.py new file mode 100644 index 0000000000..48d2fa3239 --- /dev/null +++ b/pySDC/projects/compression/test.py @@ -0,0 +1,18 @@ +a = [1, 2, 3] +b = [6, 7, 8, 9] +c = [12, 4] +d = [a, b, c] + +idx = 0 +flag = False +for values in d: + idx += 1 + print(values) + for value in values: + if 6 == value: + flag = True + print(value) + break + if flag: + break +print(idx) diff --git a/pySDC/tests/test_projects/test_compression/test_cache_manager.py b/pySDC/tests/test_projects/test_compression/test_cache_manager.py new file mode 100644 index 0000000000..ad04774b11 --- /dev/null +++ b/pySDC/tests/test_projects/test_compression/test_cache_manager.py @@ -0,0 +1 @@ +# To add two tests here diff --git a/pySDC/tests/test_projects/test_compression/test_manager.py b/pySDC/tests/test_projects/test_compression/test_manager.py index 58a5c5322f..9de4287bba 100644 --- a/pySDC/tests/test_projects/test_compression/test_manager.py +++ b/pySDC/tests/test_projects/test_compression/test_manager.py @@ -38,33 +38,17 @@ def test_mesh_operations(): np_arr1 = np.ones((30,)) * 3.0 - assert all( - me == 3.0 for me in (arr1 + arr2) - ), "Addition of two compressed meshes failed unexpectedly." - assert all( - me == -1 for me in (arr1 - arr2) - ), "Subtraction of two compressed meshes failed unexpectedly." - assert all( - me == 4 for me in (arr1 + np_arr1) - ), "Addition of a compressed mesh and numpy array failed unexpectedly." + assert all(me == 3.0 for me in (arr1 + arr2)), "Addition of two compressed meshes failed unexpectedly." + assert all(me == -1 for me in (arr1 - arr2)), "Subtraction of two compressed meshes failed unexpectedly." + assert all(me == 4 for me in (arr1 + np_arr1)), "Addition of a compressed mesh and numpy array failed unexpectedly." assert all( me == -2 for me in (arr1 - np_arr1) ), "Subtraction of a compressed mesh and numpy array failed unexpectedly." - assert all( - me == 5 for me in (4.0 + arr1) - ), "Addition of a float and compressed mesh failed unexpectedly." - assert all( - me == 2 for me in (4.0 - arr2) - ), "Subtraction of a float and compressed mesh failed unexpectedly." - assert all( - me == 4 for me in (4.0 * arr1) - ), "Multiplication of a float and compressed mesh failed unexpectedly." - assert all( - me == 5 for me in (arr1 + 4.0) - ), "Addition of a compressed mesh and float failed unexpectedly." - assert all( - me == -2 for me in (arr2 - 4.0) - ), "Subtraction of a compressed mesh and float failed unexpectedly." + assert all(me == 5 for me in (4.0 + arr1)), "Addition of a float and compressed mesh failed unexpectedly." + assert all(me == 2 for me in (4.0 - arr2)), "Subtraction of a float and compressed mesh failed unexpectedly." + assert all(me == 4 for me in (4.0 * arr1)), "Multiplication of a float and compressed mesh failed unexpectedly." + assert all(me == 5 for me in (arr1 + 4.0)), "Addition of a compressed mesh and float failed unexpectedly." + assert all(me == -2 for me in (arr2 - 4.0)), "Subtraction of a compressed mesh and float failed unexpectedly." if __name__ == "__main__": diff --git a/pySDC/tests/test_projects/test_compression/test_proof_of_concept.py b/pySDC/tests/test_projects/test_compression/test_proof_of_concept.py index 258a0c2c56..657e701438 100644 --- a/pySDC/tests/test_projects/test_compression/test_proof_of_concept.py +++ b/pySDC/tests/test_projects/test_compression/test_proof_of_concept.py @@ -18,9 +18,7 @@ def test_compression_proof_of_concept(thresh, useMPI, num_procs): p = subprocess.Popen(cmd, env=my_env, cwd=".") p.wait() - assert ( - p.returncode == 0 - ), "ERROR: did not get return code 0, got %s with %2i processes" % ( + assert p.returncode == 0, "ERROR: did not get return code 0, got %s with %2i processes" % ( p.returncode, num_procs, ) @@ -63,8 +61,6 @@ def run_single_test(thresh, useMPI, num_procs): # execute test if "--use-subprocess" in sys.argv: - test_compression_proof_of_concept( - thresh=thresh, useMPI=useMPI, num_procs=num_procs - ) + test_compression_proof_of_concept(thresh=thresh, useMPI=useMPI, num_procs=num_procs) else: run_single_test(thresh=thresh, useMPI=useMPI, num_procs=num_procs) From 9ba7be7369171a33fe575b6be8e215e91c44e775 Mon Sep 17 00:00:00 2001 From: Sansriti Ranjan Date: Sat, 25 Nov 2023 10:40:50 -0500 Subject: [PATCH 3/5] Modifying cache manager file --- pySDC/projects/compression/CRAM_Manager.py | 4 ++-- pySDC/projects/compression/cache_manager.py | 23 +++++++-------------- 2 files changed, 9 insertions(+), 18 deletions(-) diff --git a/pySDC/projects/compression/CRAM_Manager.py b/pySDC/projects/compression/CRAM_Manager.py index 21720af390..d7fb162b8a 100644 --- a/pySDC/projects/compression/CRAM_Manager.py +++ b/pySDC/projects/compression/CRAM_Manager.py @@ -54,7 +54,7 @@ def registerVar( self, varName, shape, - dtype=np.dtype("float64"), + dtype=np.dtype('float64') if np.dtype is None else np.dtype, numVectors=1, errBoundMode=None, compType=None, @@ -410,7 +410,7 @@ def getWrapperTime(self): if __name__ == "__main__": arr = np.random.rand(100, 100) # declare global instance of memory - memory = CRAM_Manager(errBoundMode="PW_REL", compType="sz3", errBound=1e-5) + memory = CRAM_Manager(errBoundMode="PW_REL", compType="blosc", errBound=1e-5) memory.registerVar( "cat", diff --git a/pySDC/projects/compression/cache_manager.py b/pySDC/projects/compression/cache_manager.py index e11efc3431..a95aeeb2c0 100644 --- a/pySDC/projects/compression/cache_manager.py +++ b/pySDC/projects/compression/cache_manager.py @@ -38,21 +38,6 @@ def get(self, varName): # Add array to the cache if it doesn't exist or update the existing block of array def put(self, varName, data): - # if varName in self.cache.keys(): - # self.cache[varName] = data - # prev_count = self.cacheFrequency[varName] - # self.cacheFrequency[varName] += 1 - # count = self.cacheFrequency[varName] - # self.countCache[prev_count].remove(varName) - # if not self.countCache[prev_count]: - # self.countCache.pop(prev_count,None) - # if count not in self.countCache.keys(): - # self.countCache[count] = [] - # self.countCache[count].append(varName) - # else: - # self.countCache[count].append(varName) - - # else: # Implement LFU cache eviction policy if len(self.cache) + 1 > self.cacheSize: # get minimum count and then the first in the list is evicted and the new array is added there @@ -88,7 +73,7 @@ def put(self, varName, data): # print(self.cache) # print(self.countCache) # print('New Array Added') - except: + except KeyError: print('Failed to evict correctly') os._exit(1) else: @@ -100,3 +85,9 @@ def put(self, varName, data): self.countCache[count].append(varName) else: self.countCache[count].append(varName) + +if __name__ == "__main__": + arr = np.random.rand(100, 100) + # declare global instance of memory + memory = Cache() + print("Cache instance:") \ No newline at end of file From fcfcd26b1a165273584b74c21aca1da06b458da7 Mon Sep 17 00:00:00 2001 From: Sansriti Ranjan Date: Sat, 25 Nov 2023 12:27:42 -0500 Subject: [PATCH 4/5] Edited mesh.py file --- pySDC/implementations/datatype_classes/mesh.py | 3 ++- pySDC/projects/compression/compressed_mesh.py | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/pySDC/implementations/datatype_classes/mesh.py b/pySDC/implementations/datatype_classes/mesh.py index 6fdf1746bd..57de7d0123 100644 --- a/pySDC/implementations/datatype_classes/mesh.py +++ b/pySDC/implementations/datatype_classes/mesh.py @@ -81,7 +81,8 @@ def __array_ufunc__(self, ufunc, method, *inputs, out=None, **kwargs): args.append(input_) results = super(mesh, self).__array_ufunc__(ufunc, method, *args, **kwargs).view(mesh) - if type(self) == type(results): + # if type(self) == type(results): + if not method == 'reduce': results._comm = comm return results diff --git a/pySDC/projects/compression/compressed_mesh.py b/pySDC/projects/compression/compressed_mesh.py index 9b13aaa924..8a5d00a003 100644 --- a/pySDC/projects/compression/compressed_mesh.py +++ b/pySDC/projects/compression/compressed_mesh.py @@ -15,7 +15,7 @@ class compressed_mesh(object): manager: contains the CRAM Manager variables """ - manager = CRAM_Manager("ABS", "blosc", 1e-5, "zstd") + manager = CRAM_Manager("PW_REL", "blosc", 1e-5, "zstd") def __init__(self, init=None, val=0.0): """ From 95c63a67db0397fe11aff61c0927a633ee54b355 Mon Sep 17 00:00:00 2001 From: Sansriti Ranjan Date: Sat, 25 Nov 2023 13:06:08 -0500 Subject: [PATCH 5/5] Formatted and all edits done --- pySDC/projects/compression/cache_manager.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/pySDC/projects/compression/cache_manager.py b/pySDC/projects/compression/cache_manager.py index a95aeeb2c0..7d7e0eb7c1 100644 --- a/pySDC/projects/compression/cache_manager.py +++ b/pySDC/projects/compression/cache_manager.py @@ -86,8 +86,9 @@ def put(self, varName, data): else: self.countCache[count].append(varName) + if __name__ == "__main__": arr = np.random.rand(100, 100) # declare global instance of memory memory = Cache() - print("Cache instance:") \ No newline at end of file + print("Cache instance:")