Stop developing for @Native

Author: xia-mc

.idea/PyFastUtil.iml

@@ -311,5 +311,5 @@ def visit(self, op: str, arg: Optional[int], argVal: Any) -> None:
 
 
 # noinspection PyUnusedLocal
-def toC(func: FunctionType, arguments: Iterable[Parameter], bytecode: Bytecode, c_int: bool) -> list[str]:
+def toC(func: FunctionType, arguments: Iterable[Parameter], bytecode: Bytecode) -> list[str]:
     return _BytecodeTranslator(func, arguments, bytecode).run()

pyfastutil/native/_internal/BytecodeTranslator.py

@@ -15,7 +15,7 @@
 NATIVE_CACHE: dict[str, BuiltinFunctionType | FunctionType] = {}
 
 
-def native(func: FunctionType, c_int: bool = False) -> BuiltinFunctionType | FunctionType:
+def native(func: FunctionType) -> BuiltinFunctionType | FunctionType:
     # initialization
     params = inspect.signature(func).parameters.values()
     bytecode = Bytecode(func)
@@ -36,7 +36,7 @@ def native(func: FunctionType, c_int: bool = False) -> BuiltinFunctionType | Fun
 
     # compile
     try:
-        Compiler.compileCode(cacheFolder, func.__name__, moduleName, BytecodeTranslator.toC(func, params, bytecode, c_int))
+        Compiler.compileCode(cacheFolder, func.__name__, moduleName, BytecodeTranslator.toC(func, params, bytecode))
     except NotImplementedError:
         NATIVE_CACHE[hashed] = func
         return func

pyfastutil/native/_internal/__init__.py

@@ -1,18 +1,10 @@
 from types import FunctionType
-from typing import TypeVar, overload, Callable
+from typing import TypeVar
 
 from ._internal import native as _native
 
 __T = TypeVar("__T", bound=FunctionType)
 
 
-@overload
-def native(func: __T) -> __T: ...
-
-
-@overload
-def native(c_int: bool = False) -> Callable[[__T], __T]: ...
-
-
-def native(arg: __T | bool = None):
-    return _native(arg) if type(arg) is FunctionType else _native(arg, c_int=True)
+def native(func: __T) -> __T:
+    return _native(func)

pyfastutil/native/annotations.py

@@ -2,8 +2,8 @@
 
 from pyfastutil.native import native
 
-SIZE = 100000
-REPEAT = 100
+SIZE = 1000000
+REPEAT = 10
 
 
 def python(n):

tests/benchmark/benchmark_Native.py

@@ -0,0 +1,86 @@
+import sys
+sys.path.append("D:\\PyFastUtil")
+from typing import Optional
+from keystone import Ks, KS_ARCH_X86, KS_MODE_64
+from pyfastutil.unsafe import Ptr, Unsafe, ASM
+import timeit
+from pyfastutil.native import native
+
+SIZE = 2000
+REPEAT = 20
+
+ks = Ks(KS_ARCH_X86, KS_MODE_64)
+asmFunc: Optional[Ptr] = None
+
+
+def python(n):
+    x = 0
+    for i in range(n):
+        x += i * i
+    return x
+
+
+@native
+def native(n):
+    x = 0
+    for i in range(n):
+        x += i * i
+    return x
+
+
+def setupAsm():
+    global asmFunc
+
+    asmCode = f"""
+        mov rax, 0      # x = 0
+        mov r10, 0      # i = 0
+        for:
+        cmp r10, {SIZE} # if i >= {SIZE}
+        jnl end
+        mov r11, r10    # i * i
+        imul r11, r11
+        add rax, r11    # x += i * i
+        inc r10         # i += 1
+        jmp for
+
+        end:
+        ret
+    """
+
+    with ASM() as asm:
+        asmFunc = asm.makeFunction(ks.asm(asmCode, as_bytes=True)[0])
+
+
+def realNative():
+    with Unsafe() as unsafe:
+        return unsafe.callLongLong(asmFunc)
+
+
+def main():
+    global SIZE
+    print(f"---Python & Native & Real-Native for Benchmark---")
+    print(f"Batch size: {SIZE}")
+    print(f"Repeat: {REPEAT}\n")
+
+    setupAsm()
+    assert python(SIZE) == native(SIZE) == realNative()
+    assert native.__doc__ == "<native method>"
+
+    time_python = sum(timeit.repeat(lambda: python(SIZE), repeat=REPEAT, number=1)) / REPEAT
+    time_native = sum(timeit.repeat(lambda: native(SIZE), repeat=REPEAT, number=1)) / REPEAT
+    time_realNative = sum(timeit.repeat(realNative, repeat=REPEAT, number=1)) / REPEAT
+    speed = time_python / time_native * 100
+    speed2 = time_python / time_realNative * 100
+
+    print(f"Python time: {time_python * 1000:.2f} ms")
+    print(f"Native time: {time_native * 1000:.2f} ms")
+    print(f"Real-Native time: {time_realNative * 1000:.2f} ms\n")
+    print(f"Native speed of Python: {speed:.2f} %")
+    print(f"Real-Native speed of Python: {speed2:.2f} %\n")
+
+    with ASM() as asm:
+        asm.freeFunction(asmFunc)
+
+
+if __name__ == '__main__':
+    main()

tests/benchmark/benchmark_Native2.py

@@ -3,6 +3,7 @@
 from pyfastutil.native import native
 
 
+@unittest.skipUnless(False, "@native is ")
 class TestNative(unittest.TestCase):
     def test_add(self):
         def add(x, y):