def __init__(self, name, inputs, outputs, parallel=False):
self.name = name
self.inputs = inputs
self.outputs = outputs
self.commands = collections.OrderedDict()
self.zero = variables(name='FALSE')
self.one = variables(name='TRUE')
self.parallel = parallel
def __init__(self,
name,
inputs,
outputs,
nb,
randomize_temps=2,
carry_out=True,
carry_in=False):
'''
Adds x1 and x2 where the bit length of both is nb
Inputs will be structured as [cin x1 x2] - size(2*nb)+1
Outputs - size (b+1)
'''
mini_mod.__init__(self, name, inputs, outputs)
self.randomize_temps = randomize_temps
self.nb = nb
if not carry_in:
assert(self.nb * 2 == len(inputs)), "You need to have " + \
str(2 * self.nb) + " inputs not " + str(len(self.inputs))
else:
assert(self.nb * 2 + 1 == len(inputs)), "You need to have " + \
str(2 * self.nb + 1) + " inputs not " + str(len(self.inputs))
self.carry_list = [
variables(self.name + '_carry_' + str(i),
randomize_name=self.randomize_temps)
for i in range(self.nb + 1)
]
# TODO - Fill with zeros
assert(len(self.outputs) ==
self.nb + 1), "Output bitwidth should be length of adder: " + \
str(self.nb + 1) + " not " + str(len(self.outputs))
self.create(carry_out=carry_out, carry_in=carry_in)
def create(self, carry):
if carry:
cin = self.inputs[0]
x = self.inputs[carry]
y = self.inputs[carry + 1]
temp1 = variables(self.name + '_tmp1',
randomize_name=self.randomize_temps)
temp2 = variables(self.name + '_tmp2',
randomize_name=self.randomize_temps)
temp3 = variables(self.name + '_tmp3',
randomize_name=self.randomize_temps)
self.add(bi_assign(ass_type='xor', lhs=[x, y], rhs=temp1))
if carry:
self.add(
bi_assign(ass_type='xor',
lhs=[temp1, cin],
rhs=self.outputs[0]))
else:
self.add(
mono_assign(ass_type='alias', lhs=[temp1],
rhs=self.outputs[0]))
self.add(bi_assign(ass_type='and', lhs=[x, y], rhs=temp2))
if carry:
self.add(bi_assign(ass_type='and', lhs=[cin, temp1], rhs=temp3))
self.add(
bi_assign(ass_type='or',
lhs=[temp3, temp2],
rhs=self.outputs[1]))
else:
self.add(
mono_assign(ass_type='alias', lhs=[temp2],
rhs=self.outputs[1]))
def __init__(self,
name,
inputs,
outputs,
nb,
randomize_temps=2,
carry_out=True):
'''
Adds x1 and x2 where the bit length of both is nb
Inputs will be structured as [cin x1 x2] - size(2*nb)+1
Outputs - size (b+1)
'''
self.x = inputs[0]
self.y = inputs[1]
mini_mod.__init__(self, name, self.x + self.y, outputs)
self.len1 = len(self.x)
self.len2 = len(self.y)
if self.len1 < self.len2:
tmp = copy.deepcopy(self.x)
self.x = copy.deepcopy(self.y)
self.y = tmp
self.randomize_temps = randomize_temps
self.nb = nb
assert(self.nb == self.len1), "You need to have " + \
str(self.nb) + " inputs not " + str(len(self.x))
self.carry_list = [
variables(self.name + '_carry_' + str(i),
randomize_name=self.randomize_temps)
for i in range(self.nb + 1)
]
assert(len(self.outputs) ==
self.nb + 1), "Output bitwidth should be length of adder: " + \
str(self.nb + 1) + " not " + str(len(self.outputs))
self.create(carry_out=carry_out)
if idx < len(self.plaintext) and int(self.plaintext[idx]) == 1:
self.add(
tri_assign(ass_type='mux',
lhs=[self.inputs[idx], temp1[idx], self.zero],
rhs=temp2[idx]))
else:
self.add(
tri_assign(ass_type='mux',
lhs=[self.inputs[idx], self.one, temp1[idx]],
rhs=temp2[idx]))
if idx < len(self.inputs) - 1:
self.add(
mono_assign(ass_type='alias',
lhs=[temp2[idx]],
rhs=temp1[idx + 1]))
else:
self.add(
mono_assign(ass_type='alias',
lhs=[temp2[idx]],
rhs=rel_out))
if __name__ == '__main__':
x = variables('x')
y = variables('y')
cin = variables('cin')
s = variables('sum')
c = variables('carry')
b2_adder = oneb_adder('2b_adder', [cin, x, y], [s, c], 1)
print(b2_adder)
for i in tqdm(range(num_coms)):
proc_arr.append(
Process(target=local_str, args=(output, i, vals[i])))
proc_arr[i].start()
for i in tqdm(range(num_coms)):
proc_arr[i].join()
results = [output.get() for p in proc_arr]
for idx, val in enumerate(results):
tgt_list[val[0]] = str(val[1])
else:
tgt_list = [str(x) for x in vals]
return '\n'.join(tgt_list)
if __name__ == '__main__':
a = variables('a')
b = variables('b')
c = variables('c')
d = variables('d')
t1 = mono_assign(ass_type='not', lhs=[a], rhs=b)
print(t1)
t2 = mono_assign(ass_type='alias', lhs=[b], rhs=d)
print(t2)
t3 = bi_assign(ass_type='or', lhs=[d, c], rhs=b)
print(t3)
print("MODULE below")
t = mini_mod('addition', [a, c], b)
t.add(t1)
t.add(t2)
t.add(t3)