def get_asm():
from renmas.macros import eq32, eq128, eq32_32, eq32_128, eq128_128, eq128_32
from renmas.macros import dot_product, macro_if, broadcast
global assembler
if assembler is None:
assembler = Tdasm()
assembler.register_macro("eq128", eq128)
assembler.register_macro("eq32", eq32)
assembler.register_macro("eq128_32", eq128_32)
assembler.register_macro("eq32_128", eq32_128)
assembler.register_macro("eq128_128", eq128_128)
assembler.register_macro("eq32_32", eq32_32)
assembler.register_macro("dot", dot_product)
assembler.register_macro("if", macro_if)
assembler.register_macro("broadcast", broadcast)
return assembler
code += lst_inst2[l] + "\n"
for l in range(len(lst_inst2), len(lst_inst1)):
code += lst_inst1[l] + "\n"
return code
def arth128_32(tokens):
return arth_mix(tokens, 128, 32)
def arth32_128(tokens):
return arth_mix(tokens, 32, 128)
def arth128_128(tokens):
return arth_mix(tokens, 128, 128)
def arth32_32(tokens):
return arth_mix(tokens, 32, 32)
if __name__ == "__main__":
asm = Tdasm()
asm.register_macro("arth128", arth128)
asm.register_macro("arth32", arth32)
mc = asm.assemble(ASM_CODE)
run = Runtime()
ds = run.load("test", mc)
run.run("test")
print(ds["rez"])
def create_assembler():
assembler = Tdasm()
assembler.register_macro('mov', mov)
assembler.register_macro('lea', lea)
assembler.register_macro('eq128', arithmetic128)
assembler.register_macro('eq32', arithmetic32)
assembler.register_macro('broadcast', broadcast)
assembler.register_macro('if', macro_if)
assembler.register_macro('dot', dot_product)
assembler.register_macro('normalization', normalization)
assembler.register_macro('cross', cross_product)
assembler.register_macro('generate_one', generate_one)
assembler.register_macro('push', push)
assembler.register_macro('pop', pop)
assembler.register_macro('sqrtss', sqrtss)
return assembler
def create_assembler(self):
assembler = Tdasm()
assembler.register_macro('eq128', arithmetic128)
assembler.register_macro('eq32', arithmetic32)
assembler.register_macro('broadcast', broadcast)
assembler.register_macro('if', macro_if)
assembler.register_macro('dot', dot_product)
assembler.register_macro('normalization', normalization)
assembler.register_macro('cross', cross_product)
return assembler
def get_asm():
from renmas.macros import eq32, eq128, eq32_32, eq32_128, eq128_128, eq128_32
from renmas.macros import dot_product, macro_if, broadcast
global assembler
if assembler is None:
assembler = Tdasm()
assembler.register_macro("eq128", eq128)
assembler.register_macro("eq32", eq32)
assembler.register_macro("eq128_32", eq128_32)
assembler.register_macro("eq32_128", eq32_128)
assembler.register_macro("eq128_128", eq128_128)
assembler.register_macro("eq32_32", eq32_32)
assembler.register_macro("dot", dot_product)
assembler.register_macro("if", macro_if)
assembler.register_macro("broadcast", broadcast)
return assembler
def create_assembler(self):
assembler = Tdasm()
assembler.register_macro('eq128', arithmetic128)
assembler.register_macro('eq32', arithmetic32)
assembler.register_macro('broadcast', broadcast)
assembler.register_macro('if', macro_if)
assembler.register_macro('dot', dot_product)
assembler.register_macro('normalization', normalization)
assembler.register_macro('cross', cross_product)
return assembler
float v3[4] = 1.0, 5.5, 1.0, 2.0
float v4[4] = 1.0, 5.5, 1.0, 2.0
float v5[4] = 1.0, 5.5, 1.0, 2.0
float v6[4] = 1.0, 5.5, 1.0, 2.0
float v7[4]
#CODE
macro eq128 xmm3 = v3
macro eq128 xmm2 = v2
macro eq128 xmm5 = v1 - xmm3
macro eq128_128 v7 = xmm3 * v3, v6 = v1 + v2
#END
"""
if __name__ == "__main__":
asm = Tdasm()
asm.register_macro("eq128", eq128)
asm.register_macro("eq32", eq32)
asm.register_macro("eq128_32", eq128_32)
asm.register_macro("eq32_32", eq32_32)
asm.register_macro("eq128_128", eq128_128)
asm.register_macro("dot", dot_product)
asm.register_macro("if", macro_if)
mc = asm.assemble(ASM)
mc.print_machine_code()
runtime = Runtime()
ds = runtime.load("test", mc)
runtime.run("test")
print(ds["v6"])
print(ds["v7"])
def create_assembler():
assembler = Tdasm()
assembler.register_macro('mov', mov)
assembler.register_macro('lea', lea)
assembler.register_macro('eq128', arithmetic128)
assembler.register_macro('eq32', arithmetic32)
assembler.register_macro('broadcast', broadcast)
assembler.register_macro('if', macro_if)
assembler.register_macro('dot', dot_product)
assembler.register_macro('normalization', normalization)
assembler.register_macro('cross', cross_product)
assembler.register_macro('generate_one', generate_one)
assembler.register_macro('push', push)
assembler.register_macro('pop', pop)
assembler.register_macro('sqrtss', sqrtss)
return assembler
class TestTrigs(unittest.TestCase):
def setUp(self):
self.runtime = Runtime()
self.macro_call = MacroCall()
self.macro_call.set_runtimes([self.runtime])
self.assembler = Tdasm()
self.assembler.register_macro('call', self.macro_call.macro_call)
def check_seq(self, seq1, seq2, precision):
for x, y in zip(seq1, seq2):
self.assertAlmostEqual(x, y, precision)
def ss_test(self, func_name, func, precision=3, negative=True):
mc = self.assembler.assemble(asm_code(func_name))
ds = self.runtime.load('test_fun', mc)
for x in range(100):
if negative:
num = (random() - 0.5) * 2
else:
num = random()
ds["v1"] = (num, num, num, num)
self.runtime.run("test_fun")
rez_asm = ds["v1"][0]
self.assertAlmostEqual(rez_asm, func(num), precision)
def ps_test(self, func_name, func, precision=3, negative=True):
mc = self.assembler.assemble(asm_code(func_name))
ds = self.runtime.load('test_fun', mc)
for x in range(100):
if negative:
num1, num2, num3, num4 = [(random() - 0.5) * 2
for i in range(4)]
else:
num1, num2, num3, num4 = random(), random(), random(), random()
ds["v1"] = (num1, num2, num3, num4)
self.runtime.run("test_fun")
rez_asm = ds["v1"]
self.check_seq(
rez_asm,
[func(num1), func(num2),
func(num3), func(num4)], precision)
def test_sin(self):
self.ss_test('fast_sin_ss', sin)
def test_sin_ps(self):
self.ps_test('fast_sin_ps', sin)
def test_cos(self):
self.ss_test('fast_cos_ss', cos)
def test_cos_ps(self):
self.ps_test('fast_cos_ps', cos)
def test_exp(self):
self.ss_test('fast_exp_ss', exp)
def test_exp_ps(self):
self.ps_test('fast_exp_ps', exp)
def test_atan(self):
self.ss_test('fast_atan_ss', atan)
def test_atan_ps(self):
self.ps_test('fast_atan_ps', atan)
def test_asin(self):
self.ss_test('fast_asin_ss', asin)
def test_asin_ps(self):
self.ps_test('fast_asin_ps', asin)
def test_acos(
self
): # FIXME function calculate wrong result for negative numbers
self.ss_test('fast_acos_ss', acos, precision=2, negative=False)
def test_acos_ps(self):
self.ps_test('fast_acos_ps', acos, precision=2)
def test_tan(self):
self.ss_test('fast_tan_ss', tan)
def test_tan_ps(self):
self.ps_test('fast_tan_ps', tan)
def test_log(self):
self.ss_test('fast_log_ss', log, negative=False)
def test_log_ps(self):
self.ps_test('fast_log_ps', log, negative=False)
def test_pow_ss(self):
mc = self.assembler.assemble(asm_code('fast_pow_ss'))
ds = self.runtime.load('test_fun', mc)
for x in range(100):
num = random()
ds["v1"] = (num, num, num, num)
num2 = (random() - 0.5) * 2
ds["v2"] = (num2, num2, num2, num2)
self.runtime.run("test_fun")
rez_asm = ds["v1"][0]
self.assertAlmostEqual(rez_asm, pow(num, num2), 2)
def test_pow_ps(self):
mc = self.assembler.assemble(asm_code('fast_pow_ps'))
ds = self.runtime.load('test_fun', mc)
for x in range(100):
num1, num2, num3, num4 = random(), random(), random(), random()
ds["v1"] = (num1, num2, num3, num4)
num5, num6, num7, num8 = [(random() - 0.5) * 2 for i in range(4)]
ds["v2"] = (num5, num6, num7, num8)
self.runtime.run("test_fun")
rez_asm = ds["v1"]
self.check_seq(rez_asm, [
pow(num1, num5),
pow(num2, num6),
pow(num3, num7),
pow(num4, num8)
], 2)
def test_atanr2_ss(self):
mc = self.assembler.assemble(asm_code('fast_atanr2_ss'))
ds = self.runtime.load('test_fun', mc)
for x in range(100):
num = (random() - 0.5) * 2
ds["v1"] = (num, num, num, num)
num2 = (random() - 0.5) * 2
ds["v2"] = (num2, num2, num2, num2)
self.runtime.run("test_fun")
rez_asm = ds["v1"][0]
self.assertAlmostEqual(rez_asm, atan2(num, 1.0 / num2), 2)
def test_atanr2_ps(self):
mc = self.assembler.assemble(asm_code('fast_atanr2_ps'))
ds = self.runtime.load('test_fun', mc)
for x in range(100):
num1, num2, num3, num4 = [(random() - 0.5) * 2 for i in range(4)]
ds["v1"] = (num1, num2, num3, num4)
num5, num6, num7, num8 = [(random() - 0.5) * 2 for i in range(4)]
ds["v2"] = (num5, num6, num7, num8)
self.runtime.run("test_fun")
rez_asm = ds["v1"]
self.check_seq(rez_asm, [
atan2(num1, 1.0 / num5),
atan2(num2, 1.0 / num6),
atan2(num3, 1.0 / num7),
atan2(num4, 1.0 / num8)
], 2)
def test_sincos_ss(self):
mc = self.assembler.assemble(asm_code('fast_sincos_ss'))
ds = self.runtime.load('test_fun', mc)
for x in range(100):
num = (random() - 0.5) * 2
ds["v1"] = (num, num, num, num)
self.runtime.run("test_fun")
sin_asm = ds["v1"][0]
cos_asm = ds["v2"][0]
self.assertAlmostEqual(sin_asm, sin(num), 2)
self.assertAlmostEqual(cos_asm, cos(num), 2)
def test_sincos_ps(self):
mc = self.assembler.assemble(asm_code('fast_sincos_ps'))
ds = self.runtime.load('test_fun', mc)
for x in range(100):
num1, num2, num3, num4 = [(random() - 0.5) * 2 for i in range(4)]
ds["v1"] = (num1, num2, num3, num4)
self.runtime.run("test_fun")
sin_asm = ds["v1"]
cos_asm = ds["v2"]
self.check_seq(
sin_asm,
[sin(num1), sin(num2),
sin(num3), sin(num4)], 3)
self.check_seq(
cos_asm,
[cos(num1), cos(num2),
cos(num3), cos(num4)], 3)
def _create_assembler(self):
assembler = Tdasm()
self._macro_call = macro_call = MacroCall()
assembler.register_macro('call', macro_call.macro_call)
assembler.register_macro('eq128', arithmetic128)
assembler.register_macro('eq32', arithmetic32)
assembler.register_macro('broadcast', broadcast)
assembler.register_macro('if', macro_if)
assembler.register_macro('dot', dot_product)
assembler.register_macro('normalization', normalization)
assembler.register_macro('cross', cross_product)
self._macro_spectrum = MacroSpectrum(self)
assembler.register_macro('spectrum', self._macro_spectrum.macro_spectrum)
return assembler
class TestTrigs(unittest.TestCase):
def setUp(self):
self.runtime = Runtime()
self.macro_call = MacroCall()
self.macro_call.set_runtimes([self.runtime])
self.assembler = Tdasm()
self.assembler.register_macro('call', self.macro_call.macro_call)
def check_seq(self, seq1, seq2, precision):
for x, y in zip(seq1, seq2):
self.assertAlmostEqual(x, y, precision)
def ss_test(self, func_name, func, precision=3, negative=True):
mc = self.assembler.assemble(asm_code(func_name))
ds = self.runtime.load('test_fun', mc)
for x in range(100):
if negative:
num = (random() - 0.5) * 2
else:
num = random()
ds["v1"] = (num, num, num, num)
self.runtime.run("test_fun")
rez_asm = ds["v1"][0]
self.assertAlmostEqual(rez_asm, func(num), precision)
def ps_test(self, func_name, func, precision=3, negative=True):
mc = self.assembler.assemble(asm_code(func_name))
ds = self.runtime.load('test_fun', mc)
for x in range(100):
if negative:
num1, num2, num3, num4 = [(random() - 0.5)*2 for i in range(4)]
else:
num1, num2, num3, num4 = random(), random(), random(), random()
ds["v1"] = (num1, num2, num3, num4)
self.runtime.run("test_fun")
rez_asm = ds["v1"]
self.check_seq(rez_asm, [func(num1), func(num2), func(num3), func(num4)], precision)
def test_sin(self):
self.ss_test('fast_sin_ss', sin)
def test_sin_ps(self):
self.ps_test('fast_sin_ps', sin)
def test_cos(self):
self.ss_test('fast_cos_ss', cos)
def test_cos_ps(self):
self.ps_test('fast_cos_ps', cos)
def test_exp(self):
self.ss_test('fast_exp_ss', exp)
def test_exp_ps(self):
self.ps_test('fast_exp_ps', exp)
def test_atan(self):
self.ss_test('fast_atan_ss', atan)
def test_atan_ps(self):
self.ps_test('fast_atan_ps', atan)
def test_asin(self):
self.ss_test('fast_asin_ss', asin)
def test_asin_ps(self):
self.ps_test('fast_asin_ps', asin)
def test_acos(self): # FIXME function calculate wrong result for negative numbers
self.ss_test('fast_acos_ss', acos, precision=2, negative=False)
def test_acos_ps(self):
self.ps_test('fast_acos_ps', acos, precision=2)
def test_tan(self):
self.ss_test('fast_tan_ss', tan)
def test_tan_ps(self):
self.ps_test('fast_tan_ps', tan)
def test_log(self):
self.ss_test('fast_log_ss', log, negative=False)
def test_log_ps(self):
self.ps_test('fast_log_ps', log, negative=False)
def test_pow_ss(self):
mc = self.assembler.assemble(asm_code('fast_pow_ss'))
ds = self.runtime.load('test_fun', mc)
for x in range(100):
num = random()
ds["v1"] = (num, num, num, num)
num2 = (random() - 0.5) * 2
ds["v2"] = (num2, num2, num2, num2)
self.runtime.run("test_fun")
rez_asm = ds["v1"][0]
self.assertAlmostEqual(rez_asm, pow(num, num2), 2)
def test_pow_ps(self):
mc = self.assembler.assemble(asm_code('fast_pow_ps'))
ds = self.runtime.load('test_fun', mc)
for x in range(100):
num1, num2, num3, num4 = random(), random(), random(), random()
ds["v1"] = (num1, num2, num3, num4)
num5, num6, num7, num8 = [(random() - 0.5)*2 for i in range(4)]
ds["v2"] = (num5, num6, num7, num8)
self.runtime.run("test_fun")
rez_asm = ds["v1"]
self.check_seq(rez_asm, [pow(num1, num5), pow(num2, num6), pow(num3, num7), pow(num4, num8)], 2)
def test_atanr2_ss(self):
mc = self.assembler.assemble(asm_code('fast_atanr2_ss'))
ds = self.runtime.load('test_fun', mc)
for x in range(100):
num = (random() - 0.5) * 2
ds["v1"] = (num, num, num, num)
num2 = (random() - 0.5) * 2
ds["v2"] = (num2, num2, num2, num2)
self.runtime.run("test_fun")
rez_asm = ds["v1"][0]
self.assertAlmostEqual(rez_asm, atan2(num, 1.0/num2), 2)
def test_atanr2_ps(self):
mc = self.assembler.assemble(asm_code('fast_atanr2_ps'))
ds = self.runtime.load('test_fun', mc)
for x in range(100):
num1, num2, num3, num4 = [(random() - 0.5)*2 for i in range(4)]
ds["v1"] = (num1, num2, num3, num4)
num5, num6, num7, num8 = [(random() - 0.5)*2 for i in range(4)]
ds["v2"] = (num5, num6, num7, num8)
self.runtime.run("test_fun")
rez_asm = ds["v1"]
self.check_seq(rez_asm, [atan2(num1, 1.0/num5), atan2(num2, 1.0/num6), atan2(num3, 1.0/num7), atan2(num4, 1.0/num8)], 2)
def test_sincos_ss(self):
mc = self.assembler.assemble(asm_code('fast_sincos_ss'))
ds = self.runtime.load('test_fun', mc)
for x in range(100):
num = (random() - 0.5) * 2
ds["v1"] = (num, num, num, num)
self.runtime.run("test_fun")
sin_asm = ds["v1"][0]
cos_asm = ds["v2"][0]
self.assertAlmostEqual(sin_asm, sin(num), 2)
self.assertAlmostEqual(cos_asm, cos(num), 2)
def test_sincos_ps(self):
mc = self.assembler.assemble(asm_code('fast_sincos_ps'))
ds = self.runtime.load('test_fun', mc)
for x in range(100):
num1, num2, num3, num4 = [(random() - 0.5)*2 for i in range(4)]
ds["v1"] = (num1, num2, num3, num4)
self.runtime.run("test_fun")
sin_asm = ds["v1"]
cos_asm = ds["v2"]
self.check_seq(sin_asm, [sin(num1), sin(num2), sin(num3), sin(num4)], 3)
self.check_seq(cos_asm, [cos(num1), cos(num2), cos(num3), cos(num4)], 3)
code = """
#DATA
float v1[4]
float v2[4]
#CODE
movaps xmm0, oword [v1]
movaps xmm1, oword [v2]
"""
code += "macro call " + func_name + """
movaps oword [v1], xmm0
movaps oword [v2], xmm6
#END
"""
return code
runtime = Runtime()
macro_call = MacroCall()
macro_call.set_runtimes([runtime])
assembler = Tdasm()
assembler.register_macro('call', macro_call.macro_call)
assembler.assemble(asm_code('fast_sin_ps'))
assembler.assemble(asm_code('fast_cos_ps'))
start = time.clock()
runtime = Runtime()
macro_call.set_runtimes([runtime])
end = time.clock()
print(end-start)
def _create_assembler(self):
assembler = Tdasm()
self._macro_call = macro_call = MacroCall()
assembler.register_macro('call', macro_call.macro_call)
assembler.register_macro('eq128', arithmetic128)
assembler.register_macro('eq32', arithmetic32)
assembler.register_macro('broadcast', broadcast)
assembler.register_macro('if', macro_if)
assembler.register_macro('dot', dot_product)
assembler.register_macro('normalization', normalization)
assembler.register_macro('cross', cross_product)
self._macro_spectrum = MacroSpectrum(self)
assembler.register_macro('spectrum',
self._macro_spectrum.macro_spectrum)
return assembler
