def _make_thread_activate(threads, sdata, sync_ops, sregistry):
if threads.size == 1:
d = threads.index
else:
d = Symbol(name=sregistry.make_name(prefix=threads.index.name))
sync_locks = [s for s in sync_ops if s.is_SyncLock]
condition = Or(*([CondNe(s.handle, 2) for s in sync_locks] +
[CondNe(FieldFromComposite(sdata._field_flag, sdata[d]), 1)]))
if threads.size == 1:
activation = [While(condition)]
else:
activation = [DummyExpr(d, 0),
While(condition, DummyExpr(d, (d + 1) % threads.size))]
activation.extend([DummyExpr(FieldFromComposite(i.name, sdata[d]), i)
for i in sdata.dynamic_fields])
activation.extend([DummyExpr(s.handle, 0) for s in sync_locks])
activation.append(DummyExpr(FieldFromComposite(sdata._field_flag, sdata[d]), 2))
activation = List(
header=[c.Line(), c.Comment("Activate `%s`" % threads.name)],
body=activation,
footer=c.Line()
)
return activation
def _make_thread_func(name, iet, root, threads, sregistry):
# Create the SharedData, that is the data structure that will be used by the
# main thread to pass information dows to the child thread(s)
required, parameters, dynamic_parameters = diff_parameters(iet, root)
parameters = sorted(parameters, key=lambda i: i.is_Function) # Allow casting
sdata = SharedData(name=sregistry.make_name(prefix='sdata'), npthreads=threads.size,
fields=required, dynamic_fields=dynamic_parameters)
sbase = sdata.symbolic_base
sid = sdata.symbolic_id
# Create a Callable to initialize `sdata` with the known const values
iname = 'init_%s' % sdata.dtype._type_.__name__
ibody = [DummyExpr(FieldFromPointer(i._C_name, sbase), i._C_symbol)
for i in parameters]
ibody.extend([
BlankLine,
DummyExpr(FieldFromPointer(sdata._field_id, sbase), sid),
DummyExpr(FieldFromPointer(sdata._field_flag, sbase), 1)
])
iparameters = parameters + [sdata, sid]
isdata = Callable(iname, ibody, 'void', iparameters, 'static')
# Prepend the SharedData fields available upon thread activation
preactions = [DummyExpr(i, FieldFromPointer(i.name, sbase))
for i in dynamic_parameters]
# Append the flag reset
postactions = [List(body=[
BlankLine,
DummyExpr(FieldFromPointer(sdata._field_flag, sbase), 1)
])]
iet = List(body=preactions + [iet] + postactions)
# The thread has work to do when it receives the signal that all locks have
# been set to 0 by the main thread
iet = Conditional(CondEq(FieldFromPointer(sdata._field_flag, sbase), 2), iet)
# The thread keeps spinning until the alive flag is set to 0 by the main thread
iet = While(CondNe(FieldFromPointer(sdata._field_flag, sbase), 0), iet)
# pthread functions expect exactly one argument, a void*, and must return void*
tretval = 'void*'
tparameter = VoidPointer('_%s' % sdata.name)
# Unpack `sdata`
unpack = [PointerCast(sdata, tparameter), BlankLine]
for i in parameters:
if i.is_AbstractFunction:
unpack.extend([Dereference(i, sdata), PointerCast(i)])
else:
unpack.append(DummyExpr(i, FieldFromPointer(i.name, sbase)))
unpack.append(DummyExpr(sid, FieldFromPointer(sdata._field_id, sbase)))
unpack.append(BlankLine)
iet = List(body=unpack + [iet, BlankLine, Return(Macro('NULL'))])
tfunc = ThreadFunction(name, iet, tretval, tparameter, 'static')
return tfunc, isdata, sdata
def _make_thread_finalize(threads, sdata):
d = threads.index
if threads.size == 1:
callback = lambda body: body
else:
callback = lambda body: Iteration(body, d, threads.size - 1)
threadswait = List(
header=c.Comment("Wait for completion of `%s`" % threads.name),
body=callback([
While(CondEq(FieldFromComposite(sdata._field_flag, sdata[d]), 2)),
DummyExpr(FieldFromComposite(sdata._field_flag, sdata[d]), 0),
Call('pthread_join', (threads[d], Macro('NULL')))
]))
return threadswait