def import_global(module, check_depth=True, block=True):
try:
# We should only be doing something for this if we're the top-level task
if c.legion_task_get_depth(top_level.task[0]) > 0 and check_depth:
return None
except AttributeError:
raise RuntimeError(
'"import_global" must be called in a legion_python task')
if isinstance(module, str):
name = module
elif isinstance(module, unicode):
name = module
elif isinstance(module, types.ModuleType):
name = module.__name__
else:
raise TypeError(
'"module" arg to "import_global" must be a ModuleType or str type')
mapper = c.legion_runtime_generate_library_mapper_ids(
top_level.runtime[0], _unique_name.encode('utf-8'), 1)
future = c.legion_runtime_select_tunable_value(top_level.runtime[0],
top_level.context[0], 0,
mapper, 0)
num_python_procs = struct.unpack_from(
'i', ffi.buffer(c.legion_future_get_untyped_pointer(future), 4))[0]
c.legion_future_destroy(future)
assert num_python_procs > 0
# Launch an index space task across all the python
# processors to import the module in every interpreter
task_id = c.legion_runtime_generate_library_task_ids(
top_level.runtime[0], _unique_name.encode('utf-8'), 3) + 1
rect = ffi.new('legion_rect_1d_t *')
rect[0].lo.x[0] = 0
rect[0].hi.x[0] = num_python_procs - 1
domain = c.legion_domain_from_rect_1d(rect[0])
packed = name.encode('utf-8')
arglen = len(packed)
array = ffi.new('char[]', arglen)
ffi.buffer(array, arglen)[:] = packed
args = ffi.new('legion_task_argument_t *')
args[0].args = array
args[0].arglen = arglen
argmap = c.legion_argument_map_create()
launcher = c.legion_index_launcher_create(task_id, domain, args[0], argmap,
c.legion_predicate_true(), False,
mapper, 0)
future = c.legion_index_launcher_execute_reduction(
top_level.runtime[0], top_level.context[0], launcher,
c.LEGION_REDOP_SUM_INT32)
c.legion_index_launcher_destroy(launcher)
c.legion_argument_map_destroy(argmap)
if block:
result = struct.unpack_from(
'i', ffi.buffer(c.legion_future_get_untyped_pointer(future), 4))[0]
c.legion_future_destroy(future)
if result > 0:
raise ImportError('failed to globally import ' + name + ' on ' +
str(result) + ' nodes')
return None
else:
return future
def run_cmd(cmd, run_name=None):
import imp
module = imp.new_module(run_name)
setattr(module, '__name__', run_name)
setattr(module, '__package__', None)
# Hide the current module if it exists.
old_module = sys.modules.get(run_name)
sys.modules[run_name] = module
try:
code = compile(cmd, '<string>', 'exec')
exec(code, module.__dict__, module.__dict__)
except SyntaxError as ex:
traceback.print_exception(SyntaxError,ex,sys.exc_info()[2],0)
c.legion_runtime_set_return_code(1)
# Wait for execution to finish here before removing the module
# because executing tasks might still need to refer to it
future = c.legion_runtime_issue_execution_fence(
top_level.runtime[0], top_level.context[0])
# block waiting on the future
c.legion_future_wait(future, True, ffi.NULL)
c.legion_future_destroy(future)
# Make sure our module gets deleted to clean up any references
# to variables the user might have made
remove_all_aliases(module)
if old_module is not None:
sys.modules[run_name] = old_module
del module
def run_path(filename, run_name=None):
import imp
module = imp.new_module(run_name)
setattr(module, '__name__', run_name)
setattr(module, '__file__', filename)
setattr(module, '__loader__', None)
setattr(module, '__package__', run_name.rpartition('.')[0])
# Hide the current module if it exists.
old_module = sys.modules.get(run_name)
sys.modules[run_name] = module
sys.path.append(os.path.dirname(filename))
with open(filename) as f:
code = compile(f.read(), filename, 'exec')
exec(code, module.__dict__, module.__dict__)
# Wait for execution to finish here before removing the module
# because executing tasks might still need to refer to it
future = c.legion_runtime_issue_execution_fence(top_level.runtime[0],
top_level.context[0])
# block waiting on the future
c.legion_future_wait(future, True, ffi.NULL)
c.legion_future_destroy(future)
# Make sure our module gets deleted to clean up any references
# to variables the user might have made
if old_module is None:
del sys.modules[run_name]
else:
sys.modules[run_name] = old_module
del module
def run_cmd(cmd, run_name=None):
import imp
module = imp.new_module(run_name)
setattr(module, '__name__', run_name)
setattr(module, '__package__', None)
# Hide the current module if it exists.
old_module = sys.modules.get(run_name)
sys.modules[run_name] = module
code = compile(cmd, '<string>', 'eval')
exec(code, module.__dict__, module.__dict__)
# Wait for execution to finish here before removing the module
# because executing tasks might still need to refer to it
future = c.legion_runtime_issue_execution_fence(top_level.runtime[0],
top_level.context[0])
# block waiting on the future
c.legion_future_wait(future, True, ffi.NULL)
c.legion_future_destroy(future)
# Make sure our module gets deleted to clean up any references
# to variables the user might have made
if old_module is None:
del sys.modules[run_name]
else:
sys.modules[run_name] = old_module
del module
def run_repl():
try:
shell = LegionConsole()
shell.interact(banner='Welcome to Legion Python interactive console')
except (SystemExit, KeyboardInterrupt):
pass
finally:
# Save the history
shell.save_history()
# Wait for execution to finish here before removing the module
# because executing tasks might still need to refer to it
future = c.legion_runtime_issue_execution_fence(
top_level.runtime[0], top_level.context[0])
# block waiting on the future
c.legion_future_wait(future, True, ffi.NULL)
c.legion_future_destroy(future)
del shell
def run_path(filename, run_name=None):
import imp
module = imp.new_module(run_name)
setattr(module, '__name__', run_name)
setattr(module, '__file__', filename)
setattr(module, '__loader__', None)
setattr(module, '__package__', run_name.rpartition('.')[0])
# Hide the current module if it exists.
old_module = sys.modules.get(run_name)
sys.modules[run_name] = module
sys.path.append(os.path.dirname(filename))
try:
with open(filename) as f:
code = compile(f.read(), filename, 'exec')
exec(code, module.__dict__, module.__dict__)
except FileNotFoundError as ex:
print("legion_python: can't open file " + str(filename) + ": " +
str(ex))
c.legion_runtime_set_return_code(1)
except SyntaxError as ex:
traceback.print_exception(SyntaxError, ex, sys.exc_info()[2], 0)
c.legion_runtime_set_return_code(1)
except SystemExit as ex:
if ex.code is not None:
if isinstance(ex.code, int):
c.legion_runtime_set_return_code(ex.code)
else:
traceback.print_exception(SyntaxError, ex,
sys.exc_info()[2], 0)
c.legion_runtime_set_return_code(1)
# Wait for execution to finish here before removing the module
# because executing tasks might still need to refer to it
future = c.legion_runtime_issue_execution_fence(top_level.runtime[0],
top_level.context[0])
# block waiting on the future
c.legion_future_wait(future, True, ffi.NULL)
c.legion_future_destroy(future)
# Make sure our module gets deleted to clean up any references
# to variables the user might have made
remove_all_aliases(module)
if old_module is not None:
sys.modules[run_name] = old_module
del module
def legion_python_main(raw_args, user_data, proc):
raw_arg_ptr = ffi.new('char[]', bytes(raw_args))
raw_arg_size = len(raw_args)
# Execute preamble to obtain Legion API context.
task = ffi.new('legion_task_t *')
raw_regions = ffi.new('legion_physical_region_t **')
num_regions = ffi.new('unsigned *')
context = ffi.new('legion_context_t *')
runtime = ffi.new('legion_runtime_t *')
c.legion_task_preamble(
raw_arg_ptr, raw_arg_size, proc,
task, raw_regions, num_regions, context, runtime)
top_level.runtime, top_level.context, top_level.task = runtime, context, task
# Run user's script.
args = input_args(True)
start = 1
if len(args) > 1 and args[1] == '--nocr':
start += 1
local_cleanup = False
else:
local_cleanup = True
if len(args) < (start+1):
sys.argv = ['']
run_repl()
elif args[start] == '-':
sys.argv = args[start:]
run_repl()
elif args[start] == '-h':
print('usage: legion_python [--nocr] [-c cmd | -m mod | file | -] [arg] ...')
print('--nocr : disable control replication for multi-node execution')
print('-c cmd : program passed in as string (terminates option list)')
print('-h : print this help message and exit')
print('-m mod : run library module as a script (terminates option list)')
print('file : program read from script file')
print('- : program read from stdin (default; interactive mode if a tty)')
print('arg ...: arguments passed to program in sys.argv[1:]')
elif args[start] == '-c':
if len(args) > (start+1):
sys.argv = ['-c'] + list(args[start+2:])
run_cmd(args[start+1], run_name='__main__')
else:
print('Argument expected for the -c option')
c.legion_runtime_set_return_code(1)
elif args[start] == '-m':
if len(args) > (start+1):
filename = args[start+1] + '.py'
found = False
for path in sys.path:
for root,dirs,files in os.walk(path):
if filename not in files:
continue
module = os.path.join(root, filename)
sys.argv = [module] + list(args[start+2:])
run_path(module, run_name='__main__')
found = True
break
if found:
break
if not found:
print('No module named '+args[start+1])
c.legion_runtime_set_return_code(1)
else:
print('Argument expected for the -m option')
c.legion_runtime_set_return_code(1)
else:
assert start < len(args)
sys.argv = list(args[start:])
run_path(args[start], run_name='__main__')
if local_cleanup:
# If we were control replicated then we just need to do our cleanup
# Do it in reverse order so modules get FILO properties
for cleanup in reversed(cleanup_items):
cleanup()
else:
# Otherwise, run a task on every node to perform the cleanup
mapper = c.legion_runtime_generate_library_mapper_ids(
top_level.runtime[0], _unique_name.encode('utf-8'), 1)
future = c.legion_runtime_select_tunable_value(
top_level.runtime[0], top_level.context[0], 0, mapper, 0)
num_python_procs = struct.unpack_from('i',
ffi.buffer(c.legion_future_get_untyped_pointer(future),4))[0]
c.legion_future_destroy(future)
assert num_python_procs > 0
# Launch an index space task across all the python
# processors to import the module in every interpreter
task_id = c.legion_runtime_generate_library_task_ids(
top_level.runtime[0], _unique_name.encode('utf-8'), 3) + 2
rect = ffi.new('legion_rect_1d_t *')
rect[0].lo.x[0] = 0
rect[0].hi.x[0] = num_python_procs - 1
domain = c.legion_domain_from_rect_1d(rect[0])
args = ffi.new('legion_task_argument_t *')
args[0].args = ffi.NULL
args[0].arglen = 0
argmap = c.legion_argument_map_create()
launcher = c.legion_index_launcher_create(task_id, domain,
args[0], argmap, c.legion_predicate_true(), False, mapper, 0)
future_map = c.legion_index_launcher_execute(top_level.runtime[0],
top_level.context[0], launcher)
c.legion_index_launcher_destroy(launcher)
c.legion_argument_map_destroy(argmap)
# Wait for all the cleanup tasks to be done
c.legion_future_map_wait_all_results(future_map)
c.legion_future_map_destroy(future_map)
del top_level.runtime
del top_level.context
del top_level.task
# Force a garbage collection so that we know that all objects which can
# be collected are actually collected before we exit the top-level task
gc.collect()
# Execute postamble.
c.legion_task_postamble(runtime[0], context[0], ffi.NULL, 0)
def legion_python_main(raw_args, user_data, proc):
raw_arg_ptr = ffi.new('char[]', bytes(raw_args))
raw_arg_size = len(raw_args)
# Execute preamble to obtain Legion API context.
task = ffi.new('legion_task_t *')
raw_regions = ffi.new('legion_physical_region_t **')
num_regions = ffi.new('unsigned *')
context = ffi.new('legion_context_t *')
runtime = ffi.new('legion_runtime_t *')
c.legion_task_preamble(
raw_arg_ptr, raw_arg_size, proc,
task, raw_regions, num_regions, context, runtime)
top_level.runtime, top_level.context, top_level.task = runtime, context, task
# Run user's script.
args = input_args(True)
start = 1
if len(args) > 1 and args[1] == '--nocr':
start += 1
local_cleanup = False
else:
local_cleanup = True
if len(args) < (start+1):
sys.argv = ['']
run_repl()
elif args[start] == '-':
sys.argv = args[start:]
run_repl()
elif args[start] == '-c':
assert len(args) >= 3
sys.argv = ['-c'] + list(args[start+2:])
run_cmd(args[start+1], run_name='__main__')
else:
assert start < len(args)
sys.argv = list(args[start:])
run_path(args[start], run_name='__main__')
if local_cleanup:
# If we were control replicated then we just need to do our cleanup
for cleanup in cleanup_items:
cleanup()
else:
# Otherwise, run a task on every node to perform the cleanup
mapper = c.legion_runtime_generate_library_mapper_ids(
top_level.runtime[0], _unique_name.encode('utf-8'), 1)
future = c.legion_runtime_select_tunable_value(
top_level.runtime[0], top_level.context[0], 0, mapper, 0)
num_python_procs = struct.unpack_from('i',
ffi.buffer(c.legion_future_get_untyped_pointer(future),4))[0]
c.legion_future_destroy(future)
assert num_python_procs > 0
# Launch an index space task across all the python
# processors to import the module in every interpreter
task_id = c.legion_runtime_generate_library_task_ids(
top_level.runtime[0], _unique_name.encode('utf-8'), 3) + 2
rect = ffi.new('legion_rect_1d_t *')
rect[0].lo.x[0] = 0
rect[0].hi.x[0] = num_python_procs - 1
domain = c.legion_domain_from_rect_1d(rect[0])
args = ffi.new('legion_task_argument_t *')
args[0].args = ffi.NULL
args[0].arglen = 0
argmap = c.legion_argument_map_create()
launcher = c.legion_index_launcher_create(task_id, domain,
args[0], argmap, c.legion_predicate_true(), False, mapper, 0)
future_map = c.legion_index_launcher_execute(top_level.runtime[0],
top_level.context[0], launcher)
c.legion_index_launcher_destroy(launcher)
c.legion_argument_map_destroy(argmap)
# Wait for all the cleanup tasks to be done
c.legion_future_map_wait_all_results(future_map)
c.legion_future_map_destroy(future_map)
del top_level.runtime
del top_level.context
del top_level.task
# Force a garbage collection so that we know that all objects which can
# be collected are actually collected before we exit the top-level task
gc.collect()
# Execute postamble.
c.legion_task_postamble(runtime[0], context[0], ffi.NULL, 0)
