def synthesize(self, code):
old_code = spu.get_active_code()
spu.set_active_code(code)
self._load_parameters(code)
log = spu_log.SPULog()
log.setup(code)
if self.renderer is not None:
self.renderer.setup(code)
self.renderer.set_one(log.consts['ONE'])
r1_inc = var.SingleFloat()
r2_inc = var.SingleFloat()
r1 = var.SingleFloat()
r2 = var.SingleFloat()
result = var.SingleFloat()
pattern = var.Word(0)
self.ly_point.set_pattern_reg(pattern)
self.ly_point.set_result_reg(result)
self.ly_point.set_r_regs(r1, r2)
self.ly_point.set_log(log)
self.ly_point.setup(code)
spu.lqa(r1, 0)
spu.lqa(r2, 4)
spu.lqa(r1_inc, 8)
spu.lqa(r2_inc, 12)
spu.lqa(pattern, 16)
for y in spuiter.syn_iter(code, self.h):
spu.lqa(r1, 0)
for x in spuiter.syn_iter(code, self.w / 4):
self.ly_point.synthesize(code)
r1.v = spu.fa.ex(r1, r1_inc)
if self.renderer is not None:
# result.v = spu.fm.ex(r1, r2)
self.renderer.set_result_reg(result)
self.renderer.synthesize(code)
if self.renderer is not None:
self.renderer.row_complete(code)
r2.v = spu.fa.ex(r2, r2_inc)
# return Numeric.where(Numeric.less(results, 0), results, 0)
spu.set_active_code(old_code)
return
def synthesize(self, code):
old_code = spu.get_active_code()
spu.set_active_code(code)
# Sanity checks
if self._x_addr is None: raise Exception("Please set x_addr")
if self._y_addr is None: raise Exception("Please set y_addr")
if self._n_bits is None: raise Exception("Please set n_bits")
if self._m is None: raise Exception("Please set m")
if self._n is None: raise Exception("Please set n")
# Acquire a registers for the bit vectors and result
n_vecs = self._n_bits / 128
x_regs = [code.acquire_register() for i in range(n_vecs)]
y_regs = [code.acquire_register() for i in range(n_vecs)]
result = code.acquire_register()
x_addr = var.Word()
y_addr = var.Word()
if self._save_op is not None:
if self._threshold is not None:
threshold = var.SingleFloat(self._threshold)
else:
threshold = var.SingleFloat(0.0)
bcmp = var.Word(0)
# Setup the Tanimito kernel
tan = Tanimoto()
tan.set_n_bits(self._n_bits)
tan.set_x_regs(x_regs)
tan.set_y_regs(y_regs)
tan.set_result(result)
tan.synthesize_constants(code)
# Setup the save op
save_op = self._save_op
if save_op is not None:
save_op.setup()
# Create the iterators
xiter = spuiter.syn_iter(code, self._m)
yiter = spuiter.syn_iter(code, self._n)
# Synthesize the block comparison loops
x_addr.v = self._x_addr
for x_off in xiter:
x_addr.v = x_addr + 16 * n_vecs
y_addr.v = self._y_addr
self._load_bit_vector(x_addr, x_regs)
for y_off in yiter:
y_addr.v = y_addr + 16 * n_vecs
self._load_bit_vector(y_addr, y_regs)
tan.synthesize(code)
if save_op is not None:
spu.fcgt(bcmp, result, threshold)
save_op.test(bcmp, result, x_off, y_off)
# /x_off
if old_code is not None:
spu.set_active_code(old_code)
return
def synthesize(self, code):
self._check_inputs()
old_code = spu.get_active_code()
spu.set_active_code(code)
zero = var.Word(reg=code.r_zero)
one = self.log.consts['ONE']
two = self.consts['TWO']
x = var.Word(self.x0)
r = var.Word(0)
cmp = var.Word(0)
x_neg = var.Word(0)
fmax = var.Word(self.max_init)
temp = var.SingleFloat()
fmax.v = spu.cuflt.ex(fmax, 155)
# Init
for i in spuiter.syn_iter(code, self.max_init):
# x = r[i % r_max] * x * (1.0 - x)
self._next_r(r)
temp.v = spu.fs.ex(one, x)
x.v = spu.fm.ex(x, temp)
x.v = spu.fm.ex(r, x)
# if x == float('-infinity'):
# return -10.0
# Derive Exponent
total = var.Word(0)
logx = var.SingleFloat()
for i in spuiter.syn_iter(code, self.max_n):
# x = ri * x * (1.0 - x)
self._next_r(r)
temp.v = spu.fs.ex(one, x)
x.v = spu.fm.ex(x, temp)
x.v = spu.fm.ex(r, x)
# logx = ri - 2.0 * ri * x
logx.v = spu.fm.ex(two, x)
logx.v = spu.fm.ex(r, logx)
logx.v = spu.fs.ex(r, logx)
# abs(logx)
x_neg.v = spu.fs.ex(zero, logx)
cmp.v = spu.fcgt.ex(logx, zero)
logx.v = spu.selb.ex(x_neg, logx, cmp)
# logx.v = spu.selb.ex(logx, x_neg, cmp)
# log(logx)
self.log.set_result(logx)
self.log.set_x(logx)
self.log.synthesize(code)
# total = total + x
total.v = spu.fa.ex(total, logx)
# return total / float(max_n)
fdiv(code, self.result, total, fmax, one)
spu.set_active_code(code)
return
