Improves python performance.

Author: modlfo

src/generators/python.ml

@@ -78,7 +78,11 @@ let uoperator (op : uoperator) =
 
 let rec print_exp (e : exp) =
   match e.e with
-  | EEmptyValue -> Pla.string "{}"
+  | EEmptyValue -> (
+    (* Create class instance based on type *)
+    match e.t.t with
+    | TStruct { path; _ } -> {%pla|<#path#s>()|}
+    | _ -> Pla.string "None")
   | EUnit -> Pla.string "None"
   | EBool v ->
     Pla.string
@@ -201,18 +205,19 @@ let rec print_exp (e : exp) =
     {%pla|[<#l#>]|}
   | EMember (e, m) ->
     let e = print_exp e in
-    {%pla|<#e#>["<#m#s>"]|}
+    {%pla|<#e#>.<#m#s>|}
   | ETMember (e, i) ->
     let e = print_exp e in
     let m = i in
     {%pla|<#e#>[<#m#i>]|}
-  | ERecord { elems; _ } ->
+  | ERecord { path; elems } ->
+    (* Generate class instantiation with keyword arguments *)
     let printElem (n, v) =
       let v = print_exp v in
-      {%pla|"<#n#s>": <#v#>|}
+      {%pla|<#n#s>=<#v#>|}
     in
     let elems = Pla.map_sep Pla.commaspace printElem elems in
-    {%pla|{<#elems#>}|}
+    {%pla|<#path#s>(<#elems#>)|}
 
 
 let rec print_lexp (e : lexp) =
@@ -221,7 +226,7 @@ let rec print_lexp (e : lexp) =
   | LId s -> Pla.string s
   | LMember (e, m) ->
     let e = print_lexp e in
-    {%pla|<#e#>["<#m#s>"]|}
+    {%pla|<#e#>.<#m#s>|}
   | LIndex { e; index = { e = EInt i; _ } } ->
     let e = print_lexp e in
     let index = i in
@@ -241,14 +246,14 @@ let print_dexp (e : dexp) =
 
 let rec print_stmt (s : stmt) =
   match s.s with
-  (* if the name is _ctx, initialize as empty dict *)
-  | StmtDecl (({ d = DId ("_ctx", _); t = { t = TStruct _; _ }; _ } as lhs), None) ->
+  (* if the name is _ctx, create a class instance *)
+  | StmtDecl (({ d = DId ("_ctx", _); t = { t = TStruct { path; _ }; _ }; _ } as lhs), None) ->
     let lhs = print_dexp lhs in
-    {%pla|<#lhs#> = {}|}
-  (* needs allocation - call allocator function *)
+    {%pla|<#lhs#> = <#path#s>()|}
+  (* needs allocation - create class instance directly *)
   | StmtDecl (({ t = { t = TStruct { path; _ }; _ }; _ } as lhs), None) ->
     let lhs = print_dexp lhs in
-    {%pla|<#lhs#> = <#path#s>_alloc()|}
+    {%pla|<#lhs#> = <#path#s>()|}
   (* declaration without value - initialize to None *)
   | StmtDecl (lhs, None) ->
     let lhs = print_dexp lhs in
@@ -332,7 +337,43 @@ let print_top_stmt (args : Util.Args.args) (t : top_stmt) =
     let body = print_body body in
     {%pla|<#def#><#body#><#><#>|}
   | TopExternal _ -> Pla.unit
-  | TopType _ -> Pla.unit
+  | TopType { path; members } ->
+    (* Generate a class with __slots__ for better performance *)
+    let member_names = CCList.map (fun (name, _, _, _) -> {%pla|'<#name#s>'|}) members |> Pla.join_sep Pla.commaspace in
+    let getDefaultValue (t : type_) =
+      match t.t with
+      | TInt -> "0"
+      | TInt16 -> "0"
+      | TReal -> "0.0"
+      | TFix16 -> "0.0"
+      | TBool -> "False"
+      | TString -> "\"\""
+      | TStruct { path; _ } -> path ^ "()"
+      | TArray (size_opt, _) -> (
+        match size_opt with
+        | Some size -> Printf.sprintf "[0.0] * %d" size
+        | None -> "[]")
+      | TList _ -> "[]"
+      | _ -> "None"
+    in
+    (* Generate __init__ with keyword arguments for record literals *)
+    let init_params =
+      CCList.map
+        (fun (name, t, _, _) ->
+          let default = getDefaultValue t in
+          {%pla|<#name#s>=<#default#s>|})
+        members
+      |> Pla.join_sep Pla.commaspace
+    in
+    let init_assignments =
+      CCList.map (fun (name, _, _, _) -> {%pla|        self.<#name#s> = <#name#s>|}) members |> Pla.join_sep Pla.newline
+    in
+    {%pla|class <#path#s>:
+    __slots__ = [<#member_names#>]
+    def __init__(self, <#init_params#>):
+<#init_assignments#>
+
+|}
   | TopAlias _ -> Pla.unit
   | TopConstant (name, _, _, _, _) when args.test_mode -> {%pla|<#name#s> = {}<#>|}
   | TopConstant (name, _, _, rhs, _) ->

test/code/ConstSpecialization.py.base

@@ -18,60 +18,108 @@ def float_to_int(i):
 def initializeArray(v, size):
     return [v for _ in range(size)]
 
+class ConstSpecialization_accumulate_type:
+    __slots__ = ['sum']
+    def __init__(self, sum=0.0):
+        self.sum = sum
+
+class ConstSpecialization_accumulate_real_2_type:
+    __slots__ = ['sum']
+    def __init__(self, sum=0.0):
+        self.sum = sum
+
+class ConstSpecialization_test_accumulate_spec_type:
+    __slots__ = ['inst_10ec4']
+    def __init__(self, inst_10ec4=ConstSpecialization_accumulate_real_2_type()):
+        self.inst_10ec4 = inst_10ec4
+
+class ConstSpecialization_test_accumulate_nonspec_type:
+    __slots__ = ['inst_17a3f']
+    def __init__(self, inst_17a3f=ConstSpecialization_accumulate_type()):
+        self.inst_17a3f = inst_17a3f
+
+class ConstSpecialization_scale_typed_real_2_type:
+    __slots__ = ['last']
+    def __init__(self, last=0.0):
+        self.last = last
+
+class ConstSpecialization_scale_typed_int_2_type:
+    __slots__ = ['last']
+    def __init__(self, last=0):
+        self.last = last
+
+class ConstSpecialization_test_typed_int_type:
+    __slots__ = ['inst_1c235']
+    def __init__(self, inst_1c235=ConstSpecialization_scale_typed_int_2_type()):
+        self.inst_1c235 = inst_1c235
+
+class ConstSpecialization_test_typed_real_type:
+    __slots__ = ['inst_15f7d']
+    def __init__(self, inst_15f7d=ConstSpecialization_scale_typed_real_2_type()):
+        self.inst_15f7d = inst_15f7d
+
+class ConstSpecialization_main_type:
+    __slots__ = ['inst_13dfa', 'inst_201fa', 'inst_3e2fa', 'inst_477fa']
+    def __init__(self, inst_13dfa=ConstSpecialization_test_accumulate_spec_type(), inst_201fa=ConstSpecialization_test_accumulate_nonspec_type(), inst_3e2fa=ConstSpecialization_test_typed_int_type(), inst_477fa=ConstSpecialization_test_typed_real_type()):
+        self.inst_13dfa = inst_13dfa
+        self.inst_201fa = inst_201fa
+        self.inst_3e2fa = inst_3e2fa
+        self.inst_477fa = inst_477fa
+
 def ConstSpecialization_accumulate_type_alloc():
-   _ctx = {}
-   _ctx["sum"] = 0.0
+   _ctx = ConstSpecialization_accumulate_type()
+   _ctx.sum = 0.0
    return _ctx
 
 
 def ConstSpecialization_accumulate_real_2_type_alloc():
-   _ctx = {}
-   _ctx["sum"] = 0.0
+   _ctx = ConstSpecialization_accumulate_real_2_type()
+   _ctx.sum = 0.0
    return _ctx
 
 
 def ConstSpecialization_test_accumulate_spec_type_alloc():
-   _ctx = {}
-   _ctx["inst_10ec4"] = ConstSpecialization_accumulate_real_2_type_alloc()
+   _ctx = ConstSpecialization_test_accumulate_spec_type()
+   _ctx.inst_10ec4 = ConstSpecialization_accumulate_real_2_type_alloc()
    return _ctx
 
 
 def ConstSpecialization_test_accumulate_nonspec_type_alloc():
-   _ctx = {}
-   _ctx["inst_17a3f"] = ConstSpecialization_accumulate_type_alloc()
+   _ctx = ConstSpecialization_test_accumulate_nonspec_type()
+   _ctx.inst_17a3f = ConstSpecialization_accumulate_type_alloc()
    return _ctx
 
 
 def ConstSpecialization_scale_typed_real_2_type_alloc():
-   _ctx = {}
-   _ctx["last"] = 0.0
+   _ctx = ConstSpecialization_scale_typed_real_2_type()
+   _ctx.last = 0.0
    return _ctx
 
 
 def ConstSpecialization_scale_typed_int_2_type_alloc():
-   _ctx = {}
-   _ctx["last"] = 0
+   _ctx = ConstSpecialization_scale_typed_int_2_type()
+   _ctx.last = 0
    return _ctx
 
 
 def ConstSpecialization_test_typed_int_type_alloc():
-   _ctx = {}
-   _ctx["inst_1c235"] = ConstSpecialization_scale_typed_int_2_type_alloc()
+   _ctx = ConstSpecialization_test_typed_int_type()
+   _ctx.inst_1c235 = ConstSpecialization_scale_typed_int_2_type_alloc()
    return _ctx
 
 
 def ConstSpecialization_test_typed_real_type_alloc():
-   _ctx = {}
-   _ctx["inst_15f7d"] = ConstSpecialization_scale_typed_real_2_type_alloc()
+   _ctx = ConstSpecialization_test_typed_real_type()
+   _ctx.inst_15f7d = ConstSpecialization_scale_typed_real_2_type_alloc()
    return _ctx
 
 
 def ConstSpecialization_main_type_alloc():
-   _ctx = {}
-   _ctx["inst_13dfa"] = ConstSpecialization_test_accumulate_spec_type_alloc()
-   _ctx["inst_201fa"] = ConstSpecialization_test_accumulate_nonspec_type_alloc()
-   _ctx["inst_3e2fa"] = ConstSpecialization_test_typed_int_type_alloc()
-   _ctx["inst_477fa"] = ConstSpecialization_test_typed_real_type_alloc()
+   _ctx = ConstSpecialization_main_type()
+   _ctx.inst_13dfa = ConstSpecialization_test_accumulate_spec_type_alloc()
+   _ctx.inst_201fa = ConstSpecialization_test_accumulate_nonspec_type_alloc()
+   _ctx.inst_3e2fa = ConstSpecialization_test_typed_int_type_alloc()
+   _ctx.inst_477fa = ConstSpecialization_test_typed_real_type_alloc()
    return _ctx
 
 
@@ -118,36 +166,36 @@ def ConstSpecialization_test_interleaved_nonspec(a):
    return ConstSpecialization_interleaved(5.0, a, 4.0, 3.0)
 
 def ConstSpecialization_accumulate_real_2(_ctx, x):
-   _ctx["sum"] = ((2.0 * x) + _ctx["sum"])
-   return _ctx["sum"]
+   _ctx.sum = ((2.0 * x) + _ctx.sum)
+   return _ctx.sum
 
 
 def ConstSpecialization_accumulate(_ctx, scale, x):
-   _ctx["sum"] = ((scale * x) + _ctx["sum"])
-   return _ctx["sum"]
+   _ctx.sum = ((scale * x) + _ctx.sum)
+   return _ctx.sum
 
 
 def ConstSpecialization_test_accumulate_spec(_ctx):
-   return ConstSpecialization_accumulate_real_2(_ctx["inst_10ec4"], 5.0)
+   return ConstSpecialization_accumulate_real_2(_ctx.inst_10ec4, 5.0)
 
 def ConstSpecialization_test_accumulate_nonspec(_ctx, s, x):
-   return ConstSpecialization_accumulate(_ctx["inst_17a3f"], s, x)
+   return ConstSpecialization_accumulate(_ctx.inst_17a3f, s, x)
 
 def ConstSpecialization_scale_typed_int_2(_ctx, x):
-   _ctx["last"] = x
+   _ctx.last = x
    return x
 
 
 def ConstSpecialization_scale_typed_real_2(_ctx, x):
-   _ctx["last"] = x
+   _ctx.last = x
    return x
 
 
 def ConstSpecialization_test_typed_int(_ctx):
-   return ConstSpecialization_scale_typed_int_2(_ctx["inst_1c235"], 42)
+   return ConstSpecialization_scale_typed_int_2(_ctx.inst_1c235, 42)
 
 def ConstSpecialization_test_typed_real(_ctx):
-   return ConstSpecialization_scale_typed_real_2(_ctx["inst_15f7d"], 3.14)
+   return ConstSpecialization_scale_typed_real_2(_ctx.inst_15f7d, 3.14)
 
 def ConstSpecialization_setArrayElement_array_of_real_size_4_real_1(m, value):
    m[1] = value
@@ -198,10 +246,10 @@ def ConstSpecialization_main(_ctx):
    r5 = ConstSpecialization_test_weighted_nonspec(0.5)
    r6 = ConstSpecialization_test_interleaved_spec()
    r7 = ConstSpecialization_test_interleaved_nonspec(1.5)
-   r8 = ConstSpecialization_test_accumulate_spec(_ctx["inst_13dfa"])
-   r9 = ConstSpecialization_test_accumulate_nonspec(_ctx["inst_201fa"], 3.0, 4.0)
-   r10 = ConstSpecialization_test_typed_int(_ctx["inst_3e2fa"])
-   r11 = ConstSpecialization_test_typed_real(_ctx["inst_477fa"])
+   r8 = ConstSpecialization_test_accumulate_spec(_ctx.inst_13dfa)
+   r9 = ConstSpecialization_test_accumulate_nonspec(_ctx.inst_201fa, 3.0, 4.0)
+   r10 = ConstSpecialization_test_typed_int(_ctx.inst_3e2fa)
+   r11 = ConstSpecialization_test_typed_real(_ctx.inst_477fa)
    inputs = initializeArray(0.0, 2)
    inputs[0] = 1.0
    inputs[1] = 2.0

test/code/DataTypes.py.base

@@ -18,41 +18,53 @@ def float_to_int(i):
 def initializeArray(v, size):
     return [v for _ in range(size)]
 
+class DataTypes_point:
+    __slots__ = ['x', 'y']
+    def __init__(self, x=0.0, y=0.0):
+        self.x = x
+        self.y = y
+
+class DataTypes_test2_type:
+    __slots__ = ['p2', 'result']
+    def __init__(self, p2=DataTypes_point(), result=DataTypes_point()):
+        self.p2 = p2
+        self.result = result
+
 def DataTypes_point_alloc():
-   _ctx = {}
-   _ctx["x"] = 0.0
-   _ctx["y"] = 0.0
+   _ctx = DataTypes_point()
+   _ctx.x = 0.0
+   _ctx.y = 0.0
    return _ctx
 
 
 def DataTypes_test2_type_alloc():
-   _ctx = {}
-   _ctx["p2"] = DataTypes_point_alloc()
-   _ctx["result"] = DataTypes_point_alloc()
+   _ctx = DataTypes_test2_type()
+   _ctx.p2 = DataTypes_point_alloc()
+   _ctx.result = DataTypes_point_alloc()
    return _ctx
 
 
 def DataTypes_addPoint1(p1, p2):
-   p3 = DataTypes_point_alloc()
-   p3["x"] = (p1["x"] + p2["x"])
-   p3["y"] = (p1["y"] + p2["y"])
+   p3 = DataTypes_point()
+   p3.x = (p1.x + p2.x)
+   p3.y = (p1.y + p2.y)
    return p3
 
 
 def DataTypes_addPoint2(p1, p2, result):
-   result["x"] = (p1["x"] + p2["x"])
-   result["y"] = (p1["y"] + p2["y"])
+   result.x = (p1.x + p2.x)
+   result.y = (p1.y + p2.y)
 
 
 def DataTypes_test1():
-   p1 = DataTypes_point_alloc()
-   p2 = DataTypes_point_alloc()
+   p1 = DataTypes_point()
+   p2 = DataTypes_point()
    result = DataTypes_addPoint1(p1, p2)
    _ = DataTypes_addPoint2(p1, p2, result)
 
 
 def DataTypes_test2(_ctx):
-   p1 = DataTypes_point_alloc()
-   _ctx["result"] = DataTypes_addPoint1(p1, _ctx["p2"])
+   p1 = DataTypes_point()
+   _ctx.result = DataTypes_addPoint1(p1, _ctx.p2)