# Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # from __future__ import print_function from collections import OrderedDict import legion # FIXME: Need a better way to determine task IDs. hello = legion.extern_task( task_id=10000, argument_types=[legion.int64, legion.float64], return_type=legion.int64, calling_convention='regent') saxpy = legion.extern_task( task_id=10001, argument_types=[legion.Region, legion.float64], privileges=[legion.RW], calling_convention='regent') @legion.task(task_id=2) def main(): print('hello from Python') x = hello(1234, 3.14) print('Python got result from Regent task: %s' % x.get())
def create_partition(is_disjoint, region, c_partition, color_space): ipart = Ipartition(c_partition.index_partition, region.ispace, color_space) return Partition(region, ipart) _constant_time_launches = False if _constant_time_launches: extern_task = legion.extern_task_wrapper else: extern_task = legion.extern_task read_config = legion.extern_task(task_id=10000, argument_types=[], privileges=[], return_type=config, calling_convention='regent') read_partitions = legion.extern_task( task_id=10001, argument_types=[Region, Region, Region, config], privileges=[N, N, N], return_type=mesh_partitions, calling_convention='regent') initialize_topology = extern_task(task_id=10003, argument_types=[ config, legion.int64, Region, Region, Region, Region, Region ],
# # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # from __future__ import print_function from collections import OrderedDict import legion # FIXME: Need a better way to determine task IDs. hello = legion.extern_task(task_id=10000, argument_types=[legion.int64, legion.float64], return_type=legion.int64, calling_convention='regent') saxpy = legion.extern_task(task_id=10001, argument_types=[legion.Region, legion.float64], privileges=[legion.RW], calling_convention='regent') @legion.task(task_id=2) def main(): print('hello from Python') x = hello(1234, 3.14) print('Python got result from Regent task: %s' % x.get()) print('creating a field space with two fields')
dest='num_neighbors', type=int, default=5) parser.add_argument('-window', dest='window', type=int, default=3) args = parser.parse_args(argv[1:]) conf = ffi.new('Config *') for field, value in vars(args).items(): setattr(conf, field, value) return conf init_piece = legion.extern_task(task_id=10002, argument_types=[ legion.int32, Config, Region, Region, Region, Region, Region ], privileges=[None, None, WD, WD, WD, N, WD], return_type=legion.void, calling_convention='regent') init_pointers = legion.extern_task( task_id=10003, argument_types=[Region, Region, Region, Region], privileges=[N, N, N, RW('in_ptr', 'in_ptr_r', 'out_ptr', 'out_ptr_r')], return_type=legion.void, calling_convention='regent') calculate_new_currents = legion.extern_task( task_id=10004, argument_types=[
# # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # from __future__ import print_function import legion from legion import task, Fspace, IndexLaunch, Ispace, Region, RW import numpy # This task is defined in C++. See init_task in python_interop.cc. init = legion.extern_task(task_id=3, privileges=[RW], return_type=legion.int64) @task def hello(i, j): print('hello %s %s' % (i, j)) # Define a Python task. This task takes two arguments: a region and a # number, and increments every element of the region by that number. @task(privileges=[RW]) def inc(R, step): # The fields of regions are numpy arrays, so you can call normal # numpy methods on them. Be careful about where the output is # directed if you want to avoid making extra copies of the data. print(R.x)
mesh_partitions = legion.Type( np.dtype([('bytes', np.void, ffi.sizeof('mesh_partitions'))]), 'mesh_partitions') config = legion.Type(np.dtype([('bytes', np.void, ffi.sizeof('config'))]), 'config') def create_partition(is_disjoint, region, c_partition, color_space): ipart = Ipartition(c_partition.index_partition, region.ispace, color_space) return Partition(region, ipart) read_config = legion.extern_task(task_id=10000, argument_types=[], privileges=[], return_type=config, calling_convention='regent') read_partitions = legion.extern_task( task_id=10001, argument_types=[Region, Region, Region, config], privileges=[N, N, N], return_type=mesh_partitions, calling_convention='regent') initialize_spans = legion.extern_task( task_id=10002, argument_types=[config, legion.int64, Region, Region, Region, Region], privileges=[None, None, RW, RW, RW, RW], return_type=legion.void,
scratch_ptr = ffi.NULL scratch_size = 0 c.task_graph_execute_point_scratch(graph, timestep, point, output_ptr, output_size, input_ptrs, input_sizes, len(inputs), scratch_ptr, scratch_size) # Hack: Not sure it's possible to generate these programmatically, so # until Legion supports variadic tasks this is what we have to do. if use_native: execute_point_task_0_0 = legion.extern_task( task_id=2, argument_types=[ task_graph, legion.uint32, legion.int32, legion.int32, Region ] + [Region] * 0, privileges=[None, None, None, None, RW('1')] + [R('0')] * 0, calling_convention='regent') execute_point_task_0_1 = legion.extern_task( task_id=3, argument_types=[ task_graph, legion.uint32, legion.int32, legion.int32, Region ] + [Region] * 1, privileges=[None, None, None, None, RW('1')] + [R('0')] * 1, calling_convention='regent') execute_point_task_0_2 = legion.extern_task( task_id=4, argument_types=[ task_graph, legion.uint32, legion.int32, legion.int32, Region ] + [Region] * 2,
['gcc', '-E', '-P', native_kernels_h_path]).decode('utf-8') lifeline_mapper_header = subprocess.check_output( ['gcc', '-E', '-P', lifeline_mapper_h_path]).decode('utf-8') ffi = cffi.FFI() ffi.cdef(native_kernels_header) ffi.cdef(lifeline_mapper_header) c = ffi.dlopen(native_kernels_so_path) memory_bound_task_id = 101 cache_bound_task_id = 102 sum_task_id = 103 c.register_native_kernels_tasks(memory_bound_task_id, cache_bound_task_id, sum_task_id) memory_bound_task = legion.extern_task(task_id=memory_bound_task_id) cache_bound_task = legion.extern_task(task_id=cache_bound_task_id) sum_task = legion.extern_task(task_id=sum_task_id, privileges=[legion.RO]) if legion.is_script: print('WARNING: unable to set mapper in script mode') else: c.register_lifeline_mapper() kernel_kind = os.environ.get('KERNEL_KIND') kernel_uses_raw = False if kernel_kind == 'memory': kernel = memory_bound_task elif kernel_kind == 'cachex': kernel = cache_bound_task elif kernel_kind == 'sum':
# # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # from __future__ import print_function import legion # FIXME: Need a better way to determine task IDs. hello = legion.extern_task(task_id=10000, argument_types=(legion.int64, legion.float64), return_type=legion.int64, calling_convention='regent') @legion.task(task_id=2) def main(): print('hello from Python') x = hello(1234, 3.14) print('Python got result from Regent task: %s' % x.get())
# http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # from __future__ import print_function import legion import numpy # This task is defined in C++. See init_task in python_interop.cc. init = legion.extern_task(task_id=3, privileges=[legion.RW], return_type=legion.int64) @legion.task def hello(i, j): print('hello %s %s' % (i, j)) # Define a Python task. This task takes two arguments: a region and a # number, and increments every element of the region by that number. @legion.task(privileges=[legion.RW]) def inc(R, step): # The fields of regions are numpy arrays, so you can call normal # numpy methods on them. Be careful about where the output is # directed if you want to avoid making extra copies of the data. print(R.x) numpy.add(R.x, step, out=R.x) print(R.x)
colors.rect[tile] = ([ idx[0] * n[0] / nt[0], clamp((idx[1] + direction) * RADIUS, 0, nt[1] * RADIUS) ], [(idx[0] + 1) * n[0] / nt[0] - 1, clamp((idx[1] + 1 + direction) * RADIUS - 1, -1, nt[1] * RADIUS - 1)]) kind = disjoint_complete if direction == 0 else disjoint_incomplete return Partition.create_by_image(points, colors_part, 'rect', tiles, kind) stencil = legion.extern_task( task_id=10001, argument_types=[ Region, Region, Region, Region, Region, Region, legion.bool_ ], privileges=[RW, N, R('input'), R('input'), R('input'), R('input')], return_type=legion.void, calling_convention='regent') increment = legion.extern_task(task_id=10002, argument_types=[ Region, Region, Region, Region, Region, Region, legion.bool_ ], privileges=[ RW('input'), N, RW('input'), RW('input'),
['gcc', '-E', '-P', native_kernels_h_path]).decode('utf-8') lifeline_mapper_header = subprocess.check_output( ['gcc', '-E', '-P', lifeline_mapper_h_path]).decode('utf-8') ffi = cffi.FFI() ffi.cdef(native_kernels_header) ffi.cdef(lifeline_mapper_header) c = ffi.dlopen(native_kernels_so_path) memory_bound_task_id = 101 cache_bound_task_id = 102 sum_task_id = 103 c.register_native_kernels_tasks(memory_bound_task_id, cache_bound_task_id, sum_task_id) memory_bound_task = legion.extern_task(task_id=memory_bound_task_id) cache_bound_task = legion.extern_task(task_id=cache_bound_task_id) sum_task = legion.extern_task(task_id=sum_task_id, privileges=[legion.RO], return_type=legion.int64) # if legion.is_script: # print('WARNING: unable to set mapper in script mode') # else: # c.register_lifeline_mapper() kernel_kind = os.environ.get('KERNEL_KIND') kernel_uses_raw = False if kernel_kind == 'memory': kernel = memory_bound_task elif kernel_kind == 'cachex':
# # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # from __future__ import print_function import legion import numpy init = legion.extern_task(task_id=3, privileges=[legion.RW]) @legion.task def f(x, y, z): print("inside task f%s" % ((x, y, z), )) return x + 1 @legion.task(privileges=[legion.RW], leaf=True) def inc(R, step): print("inside task inc%s" % ((R, step), )) # Sanity check that the values written by init are here, and that # they follow the same array ordering. print(R.x)
import psana_mpi as psana_legion legion = None else: import psana_legion import legion # Get the analysis kernel to perform on each event kernel_kind = os.environ.get('KERNEL_KIND') kernel_uses_raw = False if kernel_kind == 'memory_bound': import kernels kernel = kernels.make_memory_bound_kernel( int(os.environ.get('KERNEL_ROUNDS', 100))) elif kernel_kind == 'memory_bound_native': if legion is not None: kernel = legion.extern_task(task_id=2) else: import native_kernels kernel = native_kernels.memory_bound_kernel elif kernel_kind == 'cache_bound_native': if legion is not None: kernel = legion.extern_task(task_id=3) else: import native_kernels kernel = native_kernels.cache_bound_kernel elif kernel_kind == 'sum': kernel_uses_raw = True if legion is not None: kernel = legion.extern_task(task_id=4, privileges=[legion.RO]) else: assert False