def init(default_fp=None, default_ip=None, print_preprocessed=None, debug=None, **kwargs): if debug is None: debug = bool(int(os.environ.get('TI_DEBUG', '0'))) # Make a deepcopy in case these args reference to items from ti.cfg, which are # actually references. If no copy is made and the args are indeed references, # ti.reset() could override the args to their default values. default_fp = _deepcopy(default_fp) default_ip = _deepcopy(default_ip) kwargs = _deepcopy(kwargs) import taichi as ti ti.reset() if default_fp is not None: ti.get_runtime().set_default_fp(default_fp) if default_ip is not None: ti.get_runtime().set_default_ip(default_ip) if print_preprocessed is not None: ti.get_runtime().print_preprocessed = print_preprocessed if debug: ti.set_logging_level(ti.DEBUG) ti.cfg.debug = debug log_level = os.environ.get('TI_LOG_LEVEL', '') if log_level: ti.set_logging_level(log_level) for k, v in kwargs.items(): setattr(ti.cfg, k, v) ti.get_runtime().create_program()
def set_verbose(self, verbose): import taichi as ti if verbose: default_cfg().verbose = True ti.set_logging_level('trace') else: default_cfg().verbose = False ti.set_logging_level('error')
def init(default_fp=None, default_ip=None, print_processed=None, debug=None, **kwargs): if debug is None: import os debug = bool(int(os.environ.get('TI_DEBUG', '0'))) import taichi as ti ti.reset() if default_fp is not None: ti.get_runtime().set_default_fp(default_fp) if default_ip is not None: ti.get_runtime().set_default_ip(default_ip) if print_processed is not None: ti.get_runtime().print_preprocessed = print_processed if debug: ti.set_logging_level(ti.DEBUG) ti.cfg.debug = debug for k, v in kwargs.items(): setattr(ti.cfg, k, v) ti.get_runtime().create_program()
def init(default_fp=None, default_ip=None, print_preprocessed=None, debug=None, **kwargs): # Make a deepcopy in case these args reference to items from ti.cfg, which are # actually references. If no copy is made and the args are indeed references, # ti.reset() could override the args to their default values. default_fp = _deepcopy(default_fp) default_ip = _deepcopy(default_ip) kwargs = _deepcopy(kwargs) import taichi as ti ti.reset() if default_fp is not None: ti.get_runtime().set_default_fp(default_fp) if default_ip is not None: ti.get_runtime().set_default_ip(default_ip) if print_preprocessed is not None: ti.get_runtime().print_preprocessed = print_preprocessed if debug is None: debug = bool(int(os.environ.get('TI_DEBUG', '0'))) if debug: ti.set_logging_level(ti.TRACE) ti.cfg.debug = debug use_unified_memory = bool(int(os.environ.get('TI_USE_UNIFIED_MEMORY', '1'))) ti.cfg.use_unified_memory = use_unified_memory if not use_unified_memory: ti.warn( 'Unified memory disabled (env TI_USE_UNIFIED_MEMORY=0). This is experimental.' ) for k, v in kwargs.items(): setattr(ti.cfg, k, v) ti.get_runtime().create_program()
def init(arch=None, default_fp=None, default_ip=None, _test_mode=False, **kwargs): import taichi as ti # Make a deepcopy in case these args reference to items from ti.cfg, which are # actually references. If no copy is made and the args are indeed references, # ti.reset() could override the args to their default values. default_fp = _deepcopy(default_fp) default_ip = _deepcopy(default_ip) kwargs = _deepcopy(kwargs) ti.reset() spec_cfg = _SpecialConfig() env_comp = _EnvironmentConfigurator(kwargs, ti.cfg) env_spec = _EnvironmentConfigurator(kwargs, spec_cfg) # configure default_fp/ip: # TODO: move these stuff to _SpecialConfig too: env_default_fp = os.environ.get("TI_DEFAULT_FP") if env_default_fp: if default_fp is not None: core.warn( f'ti.init argument "default_fp" overridden by environment variable TI_DEFAULT_FP={env_default_fp}' ) if env_default_fp == '32': default_fp = f32 elif env_default_fp == '64': default_fp = f64 elif env_default_fp is not None: raise ValueError( f'Invalid TI_DEFAULT_FP={env_default_fp}, should be 32 or 64') env_default_ip = os.environ.get("TI_DEFAULT_IP") if env_default_ip: if default_ip is not None: core.warn( f'ti.init argument "default_ip" overridden by environment variable TI_DEFAULT_IP={env_default_ip}' ) if env_default_ip == '32': default_ip = i32 elif env_default_ip == '64': default_ip = i64 elif env_default_ip is not None: raise ValueError( f'Invalid TI_DEFAULT_IP={env_default_ip}, should be 32 or 64') if default_fp is not None: ti.get_runtime().set_default_fp(default_fp) if default_ip is not None: ti.get_runtime().set_default_ip(default_ip) # submodule configurations (spec_cfg): env_spec.add('print_preprocessed') env_spec.add('log_level', str) env_spec.add('gdb_trigger') env_spec.add('excepthook') # compiler configurations (ti.cfg): for key in dir(ti.cfg): if key in ['arch', 'default_fp', 'default_ip']: continue cast = type(getattr(ti.cfg, key)) if cast is bool: cast = None env_comp.add(key, cast) unexpected_keys = kwargs.keys() if len(unexpected_keys): raise KeyError( f'Unrecognized keyword argument(s) for ti.init: {", ".join(unexpected_keys)}' ) # dispatch configurations that are not in ti.cfg: if not _test_mode: ti.set_gdb_trigger(spec_cfg.gdb_trigger) ti.get_runtime().print_preprocessed = spec_cfg.print_preprocessed ti.set_logging_level(spec_cfg.log_level.lower()) if spec_cfg.excepthook: # TODO(#1405): add a way to restore old excepthook ti.enable_excepthook() # select arch (backend): env_arch = os.environ.get('TI_ARCH') if env_arch is not None: ti.info(f'Following TI_ARCH setting up for arch={env_arch}') arch = ti.core.arch_from_name(env_arch) ti.cfg.arch = adaptive_arch_select(arch) print(f'[Taichi] Starting on arch={ti.core.arch_name(ti.cfg.arch)}') if _test_mode: return spec_cfg # create a new program: ti.get_runtime().create_program()
def init(default_fp=None, default_ip=None, print_preprocessed=None, debug=None, **kwargs): # Make a deepcopy in case these args reference to items from ti.cfg, which are # actually references. If no copy is made and the args are indeed references, # ti.reset() could override the args to their default values. default_fp = _deepcopy(default_fp) default_ip = _deepcopy(default_ip) kwargs = _deepcopy(kwargs) import taichi as ti ti.reset() if default_fp is None: # won't override dfl_fp = os.environ.get("TI_DEFAULT_FP") if dfl_fp == 32: default_fp = core.DataType.f32 elif dfl_fp == 64: default_fp = core.DataType.f64 elif dfl_fp is not None: raise ValueError( f'Unrecognized TI_DEFAULT_FP: {dfl_fp}, should be 32 or 64') if default_ip is None: dfl_ip = os.environ.get("TI_DEFAULT_IP") if dfl_ip == 32: default_ip = core.DataType.i32 elif dfl_ip == 64: default_ip = core.DataType.i64 elif dfl_ip is not None: raise ValueError( f'Unrecognized TI_DEFAULT_IP: {dfl_ip}, should be 32 or 64') if print_preprocessed is None: # won't override print_preprocessed = os.environ.get("TI_PRINT_PREPROCESSED") if print_preprocessed is not None: print_preprocessed = bool(int(print_preprocessed)) if default_fp is not None: ti.get_runtime().set_default_fp(default_fp) if default_ip is not None: ti.get_runtime().set_default_ip(default_ip) if print_preprocessed is not None: ti.get_runtime().print_preprocessed = print_preprocessed if debug is None: debug = bool(int(os.environ.get('TI_DEBUG', '0'))) if debug: ti.set_logging_level(ti.TRACE) ti.cfg.debug = debug unified_memory = os.environ.get('TI_USE_UNIFIED_MEMORY', '') if unified_memory != '': use_unified_memory = bool(int(unified_memory)) ti.cfg.use_unified_memory = use_unified_memory if not use_unified_memory: ti.trace( 'Unified memory disabled (env TI_USE_UNIFIED_MEMORY=0). This is experimental.' ) for k, v in kwargs.items(): setattr(ti.cfg, k, v) def boolean_config(key, name=None): if name is None: name = 'TI_' + key.upper() value = os.environ.get(name) if value is not None: setattr(ti.cfg, key, len(value) and bool(int(value))) # does override boolean_config("print_ir") boolean_config("verbose") boolean_config("fast_math") arch = os.environ.get("TI_ARCH") if arch is not None: ti.cfg.arch = ti.core.arch_from_name(arch) log_level = os.environ.get("TI_LOG_LEVEL") if log_level is not None: ti.set_logging_level(log_level.lower()) ti.get_runtime().create_program()
def test_supported_log_levels(level): spec_cfg = ti.init(_test_mode=True) ti.set_logging_level(level) assert ti._logging.is_logging_effective(level)
def init(arch=None, default_fp=None, default_ip=None, print_preprocessed=None, debug=None, **kwargs): # Make a deepcopy in case these args reference to items from ti.cfg, which are # actually references. If no copy is made and the args are indeed references, # ti.reset() could override the args to their default values. default_fp = _deepcopy(default_fp) default_ip = _deepcopy(default_ip) kwargs = _deepcopy(kwargs) import taichi as ti ti.reset() if default_fp is None: # won't override dfl_fp = os.environ.get("TI_DEFAULT_FP") if dfl_fp == 32: default_fp = core.DataType.f32 elif dfl_fp == 64: default_fp = core.DataType.f64 elif dfl_fp is not None: raise ValueError( f'Unrecognized TI_DEFAULT_FP: {dfl_fp}, should be 32 or 64') if default_ip is None: dfl_ip = os.environ.get("TI_DEFAULT_IP") if dfl_ip == 32: default_ip = core.DataType.i32 elif dfl_ip == 64: default_ip = core.DataType.i64 elif dfl_ip is not None: raise ValueError( f'Unrecognized TI_DEFAULT_IP: {dfl_ip}, should be 32 or 64') if print_preprocessed is None: # won't override print_preprocessed = os.environ.get("TI_PRINT_PREPROCESSED") if print_preprocessed is not None: print_preprocessed = bool(int(print_preprocessed)) if default_fp is not None: ti.get_runtime().set_default_fp(default_fp) if default_ip is not None: ti.get_runtime().set_default_ip(default_ip) if print_preprocessed is not None: ti.get_runtime().print_preprocessed = print_preprocessed if debug is None: debug = bool(int(os.environ.get('TI_DEBUG', '0'))) if debug: ti.set_logging_level(ti.TRACE) ti.cfg.debug = debug unified_memory = os.environ.get('TI_USE_UNIFIED_MEMORY', '') if unified_memory != '': use_unified_memory = bool(int(unified_memory)) ti.cfg.use_unified_memory = use_unified_memory if not use_unified_memory: ti.trace( 'Unified memory disabled (env TI_USE_UNIFIED_MEMORY=0). This is experimental.' ) for k, v in kwargs.items(): setattr(ti.cfg, k, v) def bool_int(x): return bool(int(x)) def environ_config(key, cast=bool_int): name = 'TI_' + key.upper() value = os.environ.get(name, '') if len(value): setattr(ti.cfg, key, cast(value)) # TI_ASYNC= : not work # TI_ASYNC=0 : False # TI_ASYNC=1 : True # does override environ_config("print_ir") environ_config("verbose") environ_config("fast_math") environ_config("async") environ_config("print_benchmark_stat") environ_config("device_memory_fraction", float) environ_config("device_memory_GB", float) # Q: Why not environ_config("gdb_trigger")? # A: We don't have ti.cfg.gdb_trigger yet. # Discussion: https://github.com/taichi-dev/taichi/pull/879 gdb_trigger = os.environ.get('TI_GDB_TRIGGER', '') if len(gdb_trigger): ti.set_gdb_trigger(bool(int(gdb_trigger))) # Q: Why not environ_config("arch", ti.core.arch_from_name)? # A: We need adaptive_arch_select for all. env_arch = os.environ.get("TI_ARCH") if env_arch is not None: print(f'Following TI_ARCH setting up for arch={env_arch}') arch = ti.core.arch_from_name(env_arch) ti.cfg.arch = adaptive_arch_select(arch) log_level = os.environ.get("TI_LOG_LEVEL") if log_level is not None: ti.set_logging_level(log_level.lower()) ti.get_runtime().create_program()
import taichi as ti ti.init(ti.opengl, saturating_grid_dim=8) ti.set_logging_level(ti.DEBUG) @ti.kernel def func(): for i in range(10): print(i) func() ti.sync()
def init(arch=None, default_fp=None, default_ip=None, _test_mode=False, enable_fallback=True, **kwargs): """Initializes the Taichi runtime. This should always be the entry point of your Taichi program. Most importantly, it sets the backend used throughout the program. Args: arch: Backend to use. This is usually :const:`~taichi.lang.cpu` or :const:`~taichi.lang.gpu`. default_fp (Optional[type]): Default floating-point type. default_ip (Optional[type]): Default integral type. **kwargs: Taichi provides highly customizable compilation through ``kwargs``, which allows for fine grained control of Taichi compiler behavior. Below we list some of the most frequently used ones. For a complete list, please check out https://github.com/taichi-dev/taichi/blob/master/taichi/program/compile_config.h. * ``cpu_max_num_threads`` (int): Sets the number of threads used by the CPU thread pool. * ``debug`` (bool): Enables the debug mode, under which Taichi does a few more things like boundary checks. * ``print_ir`` (bool): Prints the CHI IR of the Taichi kernels. * ``packed`` (bool): Enables the packed memory layout. See https://docs.taichi.graphics/lang/articles/advanced/layout. """ # Check version for users every 7 days if not disabled by users. skip = os.environ.get("TI_SKIP_VERSION_CHECK") if skip != 'ON': try_check_version() # Make a deepcopy in case these args reference to items from ti.cfg, which are # actually references. If no copy is made and the args are indeed references, # ti.reset() could override the args to their default values. default_fp = _deepcopy(default_fp) default_ip = _deepcopy(default_ip) kwargs = _deepcopy(kwargs) ti.reset() spec_cfg = _SpecialConfig() env_comp = _EnvironmentConfigurator(kwargs, ti.cfg) env_spec = _EnvironmentConfigurator(kwargs, spec_cfg) # configure default_fp/ip: # TODO: move these stuff to _SpecialConfig too: env_default_fp = os.environ.get("TI_DEFAULT_FP") if env_default_fp: if default_fp is not None: _ti_core.warn( f'ti.init argument "default_fp" overridden by environment variable TI_DEFAULT_FP={env_default_fp}' ) if env_default_fp == '32': default_fp = ti.f32 elif env_default_fp == '64': default_fp = ti.f64 elif env_default_fp is not None: raise ValueError( f'Invalid TI_DEFAULT_FP={env_default_fp}, should be 32 or 64') env_default_ip = os.environ.get("TI_DEFAULT_IP") if env_default_ip: if default_ip is not None: _ti_core.warn( f'ti.init argument "default_ip" overridden by environment variable TI_DEFAULT_IP={env_default_ip}' ) if env_default_ip == '32': default_ip = ti.i32 elif env_default_ip == '64': default_ip = ti.i64 elif env_default_ip is not None: raise ValueError( f'Invalid TI_DEFAULT_IP={env_default_ip}, should be 32 or 64') if default_fp is not None: impl.get_runtime().set_default_fp(default_fp) if default_ip is not None: impl.get_runtime().set_default_ip(default_ip) # submodule configurations (spec_cfg): env_spec.add('print_preprocessed') env_spec.add('log_level', str) env_spec.add('gdb_trigger') env_spec.add('excepthook') env_spec.add('experimental_real_function') env_spec.add('short_circuit_operators') # compiler configurations (ti.cfg): for key in dir(ti.cfg): if key in ['arch', 'default_fp', 'default_ip']: continue _cast = type(getattr(ti.cfg, key)) if _cast is bool: _cast = None env_comp.add(key, _cast) unexpected_keys = kwargs.keys() if len(unexpected_keys): raise KeyError( f'Unrecognized keyword argument(s) for ti.init: {", ".join(unexpected_keys)}' ) # dispatch configurations that are not in ti.cfg: if not _test_mode: ti.set_gdb_trigger(spec_cfg.gdb_trigger) impl.get_runtime().print_preprocessed = spec_cfg.print_preprocessed impl.get_runtime().experimental_real_function = \ spec_cfg.experimental_real_function impl.get_runtime().short_circuit_operators = \ spec_cfg.short_circuit_operators ti.set_logging_level(spec_cfg.log_level.lower()) if spec_cfg.excepthook: # TODO(#1405): add a way to restore old excepthook ti.enable_excepthook() # select arch (backend): env_arch = os.environ.get('TI_ARCH') if env_arch is not None: ti.info(f'Following TI_ARCH setting up for arch={env_arch}') arch = _ti_core.arch_from_name(env_arch) ti.cfg.arch = adaptive_arch_select(arch, enable_fallback, ti.cfg.use_gles) if ti.cfg.arch == cc: _ti_core.set_tmp_dir(locale_encode(prepare_sandbox())) print(f'[Taichi] Starting on arch={_ti_core.arch_name(ti.cfg.arch)}') # Torch based ndarray on opengl backend allocates memory on host instead of opengl backend. # So it won't work. if ti.cfg.arch == opengl and ti.cfg.ndarray_use_torch: ti.warn( 'Opengl backend doesn\'t support torch based ndarray. Setting ndarray_use_torch to False.' ) ti.cfg.ndarray_use_torch = False if _test_mode: return spec_cfg get_default_kernel_profiler().set_kernel_profiler_mode( ti.cfg.kernel_profiler) # create a new program: impl.get_runtime().create_program() ti.trace('Materializing runtime...') impl.get_runtime().prog.materialize_runtime() impl._root_fb = FieldsBuilder() if not os.environ.get("TI_DISABLE_SIGNAL_HANDLERS", False): impl.get_runtime()._register_signal_handlers() return None