def new_func(*args, **kwargs):
#vector timer
print("\n", old_func.__name__)
start = time.time()
old_func(*args, **kwargs)
end = time.time()
no_diff = end - start + 0.001
print("\t", " without optimizations took", "%.3f" % no_diff,
"seconds to run ")
temp_f = jit(old_func)
temp_f(*args, **kwargs)
start = time.time()
temp_f(*args, **kwargs)
end = time.time()
llvm.set_option('', '--debug-only=loop-vectorize')
temp_f(*args, **kwargs)
llvm.set_option('', '--debug=None')
v_diff = end - start + 0.0001
print("\t", " with optimizations took", "%.3f" % v_diff,
"seconds to run ")
print(" It is", "%.3f" % ((no_diff) / (v_diff)),
"times faster with optimizations")
return old_func(*args, **kwargs)
from llvmlite import binding
binding.set_option("tmp", "-non-global-value-max-name-size=2048")
"""
Just in time Lake To Pond Transition
------------------------------------
Just in time Checks for transitions from lake to pond
"""
import numpy as np
from numba import jit
from .debug import DEBUG, PARALLEL
if DEBUG:
import llvmlite.binding as llvm
llvm.set_option('', '--debug-only=loop-vectorize')
@jit(parallel=PARALLEL, nopython=True, nogil=True)
def update_depth(depth_grid, elapsed_ts, depth_factor):
"""Just in time Update Depth for lake to pond
Parameters
----------
depth_grid: np.array like (float)
grid of current lake depths
elapsed_ts: float
number timesteps since start year
depth_factor: float
Returns
-------
np.array
def init_diagnostics():
llvm.set_option('', '--debug-only=loop-vectorize')
return
import argparse
from datetime import datetime, timedelta
import sys
import time
import threading
import logging
import numpy
import uhd
import pdb
import math
import pyfftw
import numba
from numba import *
import llvmlite.binding as llvm
llvm.set_option(
'',
'opt -O0 -simplifycfg -loop-rotate -debug-only=loop-vectorize list_1.ll -S -o list_2.ll && opt -O3 -debug-only=loop-vectorize list_2.ll '
)
CLOCK_TIMEOUT = 1000 # 1000mS timeout for external clock locking
INIT_DELAY = 0.05 # 50mS initial delay before transmit
def parse_args():
"""Parse the command line arguments"""
description = """UHD Benchmark Rate (Python API)
"""
parser = argparse.ArgumentParser(
formatter_class=argparse.RawTextHelpFormatter, description=description)
parser.add_argument("-a",
"--args",
default="",
import platform
import numpy as np
from numba import types
from unittest import TestCase, skipIf
from numba.tests.support import override_env_config
from numba.core.compiler import compile_isolated, Flags
from numba.core.cpu_options import FastMathOptions
_DEBUG = False
if _DEBUG:
from llvmlite import binding as llvm
# Prints debug info from the LLVMs vectorizer
llvm.set_option("", "--debug-only=loop-vectorize")
@skipIf(platform.machine() != 'x86_64', 'x86_64 only test')
class TestVectorization(TestCase):
"""
Tests to assert that code which should vectorize does indeed vectorize
"""
def gen_ir(self, func, args_tuple, fastmath=False):
with override_env_config("NUMBA_CPU_NAME",
"skylake-avx512"), override_env_config(
"NUMBA_CPU_FEATURES", ""):
_flags = Flags()
_flags.set('fastmath', FastMathOptions(fastmath))
jitted = compile_isolated(func, args_tuple, flags=_flags)
return jitted.library.get_llvm_str()
def test_nditer_loop(self):
# see https://github.com/numba/numba/issues/5033
mpm.run(mod)
if verbose:
print('====== IR (optimized) ======')
print(mod)
# Now add the module and make sure it is ready for execution
engine.add_module(mod)
engine.finalize_object()
engine.run_static_constructors()
return mod
# All these initializations are required for code generation!
binding.initialize()
binding.initialize_native_target()
binding.initialize_native_asmprinter()
binding.load_library_permanently("libsvml.so")
binding.set_option('', '-vector-library=SVML')
llvm = LLVM(CTypesFunction)
# Plugins
plugins = []
from . import default
plugins.append(default)
