need to revise assignment behavior

Author: shiinamiyuki

README.md

@@ -149,18 +149,18 @@ However, not all references can be implemented on GPU. LuisaCompute would detect
 
 The behavior can be summarize in the following table:
 
-| Type        | Assignment | Field/Index Assignment | Function Argument Passing | Function Return |
-|-------------|------------|------------------------|---------------------------|-----------------|
-| Python Object | Reference   | Reference              | Reference                 | Reference       |
-| Scalar (e.g. lc.int) | Value       | Value                  | Value                     | Value           |
-| Compound Type (e.g. lc.float3, lc.float4x4) | Reference   | Copy              | Reference                 | Reference |
+| Type        | Assignment | Field/Index Assignment | Function Argument Passing | `@lc.trace` Return | `@lc.func` Return |
+|-------------|------------|------------------------|---------------------------|-----------------|-------------|
+| Python Object | Reference   | Reference              | Reference                 | Reference       | Reference |
+| Scalar (e.g. lc.int) | Value       | N/A                  | Value                     | Value           | Value   |
+| Compound Type (e.g. lc.float3, lc.float4x4) | Reference   | Copy              | Reference                 | Reference | Value |
 
 
 Let's take a look at an example:
 
 ```python
 @lc.kernel
-def kernel_example():
+def assignment_example():
     s = MyStruct(10, lc.float3(1.0, 2.0, 3.0))
     v = lc.float3(4.0, 5.0, 6.0)
     t = s # t is a reference to s as in Python
@@ -171,28 +171,45 @@ def kernel_example():
     t2 = lc.copy(s) # t2 is a copy of s, not a reference
     t2.a += 1
     lc.print(t2.a, s.a) # should print 11, 10
+```
+
+#### Transient vs Persistent Values
+Values in LuisaCompute can be categorized into transient and persistent values. Transient values are similar to rvalues in C++, meaning that they are temporarily created and hasn't bind to any variable yet. Persistent values are similar to lvalues in C++, meaning that they are bound to a variable and can be used as assignment target.
 
-    # the following code is not allowed since such dynamically created reference cannot be implemented on GPU:
+Since phyiscal reference might be supported on GPU, it is not possible to dynamically create reference to persistent values,
+for example
+```python
+@lc.kernel
+def transient_vs_persistent():
+    v1 = lc.float3(1.0, 2.0, 3.0)
+    v2 = lc.float3(4.0, 5.0, 6.0)
+
+    # the following code is allowed since both `v1 + 1.0` and `v2 + 1.0` are transient values.
+    if dynamic_cond:
+        dynamic = v1 + 1.0
+    else:
+        dynamic = v2 + 1.0
+        
+    # the following code is not allowed since such dynamically created reference to persitent values cannot be implemented on GPU:
     if dynamic_cond:
-        dynamic = s
+        dynamic = v1
     else:
-        dynamic = t2
+        dynamic = v2
 
     # instead, you can either use lc.copy() to create a copy of the struct:
     if dynamic_cond:
-        dynamic = s
+        dynamic = lc.copy(v1)
     else:
-        dynamic = t2
+        dynamic = lc.copy(v2)
 
     # or use a static condition:
     if lc.comptime(cond):
-        dynamic = s
+        dynamic = v1
     else:
-        dynamic = t2
+        dynamic = v2
 
 ```
 
-
 ### Functions and Methods
 Functions and methods in LuisaCompute are defined using the `@lc.func` or `@lc.trace` decorators. Both decorator transforms the python function into a LuisaCompute function that can be executed on both host (native Python) and device (LuisaCompute backend). The difference is that `@lc.trace` **inline**s the function body into the caller each time it is called, while `@lc.func` creates a separate function on the device.
 

luisa_lang/hir.py

@@ -85,7 +85,8 @@ def size(self) -> int:
         raise RuntimeError("RefTypes are logical and thus do not have a size")
 
     def align(self) -> int:
-        raise RuntimeError("RefTypes are logical and thus do not have an align")
+        raise RuntimeError(
+            "RefTypes are logical and thus do not have an align")
 
     def __eq__(self, value: object) -> bool:
         return isinstance(value, RefType) and value.element == self.element
@@ -246,7 +247,8 @@ def __init__(self, element: Type, count: int, align: int | None = None) -> None:
         self.count = count
         self._align = align
         assert (self.element.size() * self.count) % self._align == 0
-        self._size = round_to_align(self.element.size() * self.count, self._align)
+        self._size = round_to_align(
+            self.element.size() * self.count, self._align)
 
     def size(self) -> int:
         return self._size
@@ -506,10 +508,11 @@ class TypeTemplate(Template[Type, TypeTemplateArgs]):
     pass
 
 
-class PyTreeStructure: # TODO: refactor this into another file
+class PyTreeStructure:  # TODO: refactor this into another file
     metadata: (
         Tuple[type, Tuple[Any], Any] | None
-    )  # for JitVars, this is (type, type_args, hir.Type), for other types, this is (type, (), Any)
+        # for JitVars, this is (type, type_args, hir.Type), for other types, this is (type, (), Any)
+    )
     children: List["PyTreeStructure"]
 
     def __init__(
@@ -764,7 +767,21 @@ def __init__(
         self.span = span
 
 
+class ValueCategory(Enum):
+    NONE = auto() # not applicable. such as for opaque types or references
+    TRANSIENT = auto()  # or r-values
+    PERSISTENT = auto()  # or l-values
+
+
 class Value(TypedNode):
+    category: ValueCategory
+
+    def __init__(self, type: Optional[Type] = None,
+                 span: Optional[Span] = None,
+                 category: ValueCategory = ValueCategory.NONE) -> None:
+        super().__init__(type, span)
+        self.category = category
+
     def is_ref(self) -> bool:
         assert self.type is not None
         return isinstance(self.type, RefType)
@@ -791,7 +808,7 @@ def __init__(
         span: Optional[Span],
         semantic: ParameterSemantic = ParameterSemantic.BYVAL,
     ) -> None:
-        assert name != ""
+        # assert name != ""
         assert not isinstance(type, RefType)
         super().__init__(type, span)
         self.name = name
@@ -801,7 +818,7 @@ def __init__(
 class VarValue(Value):
     var: Var
 
-    def __init__(self, var: Var, span: Optional[Span]) -> None:
+    def __init__(self, var: Var, span: Optional[Span] = None) -> None:
         super().__init__(var.type, span)
         self.var = var
 
@@ -878,7 +895,7 @@ class Alloca(Value):
 
     def __init__(self, ty: Type, span: Optional[Span] = None) -> None:
         # assert isinstance(ty, RefType), f"expected a RefType but got {ty}"
-        super().__init__(RefType(ty), span)
+        super().__init__(ty, span)
 
 
 # class Init(Value):
@@ -939,9 +956,11 @@ class Assign(Node):
     value: Value
 
     def __init__(self, ref: Value, value: Value, span: Optional[Span] = None) -> None:
-        assert not isinstance(value.type, (RefType)), f"expecting a non-reference value, but got {value}"
+        assert not isinstance(
+            value.type, (RefType)), f"expecting a non-reference value, but got {value}"
         if not isinstance(ref.type, RefType):
-            raise TypeCheckError(ref, f"cannot assign to a non-reference variable")
+            raise TypeCheckError(
+                ref, f"cannot assign to a non-reference variable")
         super().__init__(span)
         self.ref = ref
         self.value = value

luisa_lang/lang_runtime.py

@@ -326,10 +326,11 @@ def _init_symbolic(self):
         dsl_type = hir.get_dsl_type(self.__dtype__)
         if dsl_type is None:
             raise ValueError(f"{self.__dtype__} is not a valid DSL type")
-        self.__symbolic__ = Symbolic(
-            hir.VarRef(current_func().create_var(
-                "", dsl_type.default(), False))
-        )
+        # self.__symbolic__ = Symbolic(
+        #     hir.VarValue(current_func().create_var(
+        #         "", dsl_type.default(), False))
+        # )
+        self.__symbolic__ = Symbolic(hir.Alloca(dsl_type.default(), span=None))
 
     def _destroy_symbolic(self):
         self.__symbolic__ = None

tests/test_compile_simple.py

@@ -3,20 +3,33 @@
 import subprocess
 from luisa_lang.compile import Compiler
 
+@lc.struct
+class Point:
+    x: lc.f32
+    y: lc.f32
+
+    @lc.trace
+    def __init__(self, x: lc.f32, y: lc.f32):
+        self.x = x
+        self.y = y
+
 @lc.func
 def sqr(x):
     return x * x
 
 @lc.func
 def foo(a, b):
+    # p = Point(lc.f32(1.0), lc.f32(2.0))
+    p = Point(a, b)
+    z = sqr(a)
     if a < b:
-        return sqr(a + b)
+        return z
     else:
         return a - b
 
 
 compiler = Compiler('cpp')
-compiler.compile(foo, example_inputs=(lc.f32(1.0),lc.f32(3.0)), name="foo_example")
+compiler.compile(foo, example_inputs=(lc.f32(1.0),lc.f32(3)), name="foo_example")
 output_code = compiler.output()
 with open("test.cpp", "w") as f:
     f.write(output_code)