Difference Python and Mojo assignments (ref versus copy)

[paugier]

The difference between name spaces and object space is very important in Python (for which names are just references to objects) and it has to be understood quite soon by Python beginners.

I understood that Mojo works completely differently (for example an assignment a = b leads to a copy, arguments passing much more advanced than in Python). I think there could be a section quite early somewhere in the documentation to explicitly discuss this important difference. It could be very useful for Python developers who can simply assume that an assignment a = b just create a new reference.

For example in https://docs.modular.com/mojo/programming-manual.html#the-__copyinit__-__moveinit__-and-__takeinit__-special-methods, there is

# var b = a  # ERROR: Vector doesn't implement __copyinit__

I guess that for most Python dev without experience in another static language, this feels strange (at least too much information: (i) assignment means copy and (ii) object not copyable without __copyinit__).

Moreover, I somehow see how I could implement Mojo objects that mimic the behavior of Python types. But I don't get how one could implement a list in mojo to get something as simple as

a = list(range(2))
b = a
b[0] = 1
assert a == b
assert a is b

Is it already possible? Will it be possible? How could it be done?

[rd4com]

Hello, as a relatively new person learning the mojo language,

contributions for the last questions:

mojo do have an object type (see the matmul example and Object):

def main():
    var a = object([0,1])
    var b = a
    b[0] = 1
    print(a) #[1, 1]
    print(b) #[1, 1]

It also have a PythonObject type:

def main():
    var a = PythonObject([0,1])
    var b = a
    b.__setitem__(0,1)
    print(a) #[1, 1]
    print(b) #[1, 1]

Implementing a generic struct with pointers is also a possibility ( non memory only types or register_passable for T).
If multiples instances share the same Pointer[T], a free in one instance would affect the other so have to be thoughtful.
Special attention for not doing free two times or in the wrong order for example.
Manually doing free in the right order can be tricky and lead to bugs if not carefull.

Pretty sure with lifetimes it is gonna be ergonomical and obviously safer by design.

For the fact that a __copyinit()__ method need to be defined in order to make copy of instances:

It could a good thing, think of types that should only have one instance, it is a way to enforce that.
Some types need to be "unique", and rely on transfer of ownership with __takeinit()__ and __moveinit()__

There is the @value decorator that can synthesize a few methods including __copyinit()__ in order to avoid boilerplate/redundant coding.

I don't know how it would works with classes.

[paugier]

Interesting to see that there are builtin types who have this behavior (object([]) and PythonObject([])), but it does not tell me how one would implement that with a Mojo struct.

For a struct, an assignment involves running __copyinit__ which has the signature fn __copyinit__(inout self, borrowed existing: Self): and cannot be defined as fn __copyinit__(inout self, inout existing: Self):, so one cannot increment a reference counting of existing.

[rd4com]

If it is stored in a Pointer[Int] instead of an Int, you should be able to increment the value!

struct unsafe_my_type:
    var reference_counter: Pointer[Int] #don't forget to call free

example: call store(self: Self, offset: Int, *value: "type") on a pointer

Note: Pointer is from the Memory.unsafe module

---

Be aware when it comes to generics (in functions and structs):

fn my_func[T:AnyType](v:T)->T:
    return v

@value
struct my_struct:
    var x:Int

fn main():
    var a = my_struct(1)
    my_func(a) # error. <-------

    #thoses builtin types and others will not produce errors:
    my_func(1) # ok
    my_func(True) #ok
    my_func("Hello world") #ok

solution: my_struct would need to be register passable.

mojo is v0.5 when written the reply

[paugier]

Thanks for the help @rd4com!

I managed to get an implementation of an array acting like in Python, where one manipulate references. I post it here in case it can be interesting to someone. It works but I guess it is not the right way to do it :-)

Now I wonder if there are other (better) ways to obtain such result in Mojo without reference counting.

from memory.unsafe import Pointer, DTypePointer
from memory.memory import memset_zero


@register_passable("trivial")
struct InternalContainer[dtype: DType]:
    var data: DTypePointer[dtype]
    var size: Int
    var ref_count: Int

    fn __init__() -> Self:
        return Self {data: DTypePointer[dtype].get_null(), ref_count: 1, size: 1}

    fn __str__(self) -> String:
        var data_as_str = String("[")
        for idx in range(self.size - 1):
            let elem = self.data.load(idx)
            data_as_str += String(elem) + ", "
        let elem = self.data.load(self.size - 1)
        data_as_str += String(elem)
        data_as_str += "]"
        return (
            "InternalContainer(data="
            + data_as_str
            + ", ref_count"
            + String(self.ref_count)
            + ")"
        )

    fn incref(inout self):
        self.ref_count += 1

    fn decref(inout self):
        self.ref_count += 1

    fn free_memory(inout self):
        print("Freeing memory")
        self.data.free()

    fn __setitem__(inout self, idx: Int, value: SIMD[dtype, 1]):
        self.data.store(idx, value)


struct Array[dtype: DType]:
    var ptr_container: Pointer[InternalContainer[dtype]]

    fn __init__(inout self, size: Int):
        self.ptr_container = Pointer[InternalContainer[dtype]].alloc(1)
        var container = self.ptr_container[0]
        container.ref_count = 1
        container.size = size
        container.data = DTypePointer[dtype].alloc(size)
        memset_zero[dtype](container.data, size)
        self.ptr_container.store(0, container)
        print("end init Array")

    fn __copyinit__(inout self, borrowed existing: Self):
        print("__copyinit__")
        var container = existing.ptr_container.load(0)
        container.incref()
        existing.ptr_container.store(0, container)
        self.ptr_container = existing.ptr_container

    fn __moveinit__(inout self, owned existing: Self):
        print("__moveinit__")
        self.ptr_container = existing.ptr_container

    fn __del__(owned self):
        var container = self.ptr_container.load(0)
        print("del", self.__str__(), "refcount", container.ref_count)
        container.ref_count -= 1
        if container.ref_count == 0:
            self.ptr_container.free()
            container.free_memory()
            print("Array deleted and data freed")
        else:
            self.ptr_container.store(0, container)

    fn __str__(self) -> String:
        return "Ref(" + String(self.ptr_container.load(0).__str__())

    fn __setitem__(inout self, idx: Int, value: SIMD[dtype, 1]):
        var container = self.ptr_container.load(0)
        container[idx] = value


def main():
    a = Array[DType.int64](4)
    print("in main, a:", a.__str__())
    b = a
    print("in main, a:", a.__str__())
    print("in main, b:", b.__str__())
    a[0] = 5
    print("in main, a:", a.__str__())
    print("in main, b:", b.__str__())
    c = b
    print("in main, c:", c.__str__())

[paugier]

Much simpler implementation (for Int). Still it uses 2 pointers (unsafe code) and it cannot be generalized like that to be a reference of a Tensor (because a Tensor is not @register_passable and one can not do tensor = self.ptr_tensor[0], error message "result cannot bind generic !mlirtype to memory-only type 'Tensor[dtype]'")

struct IntRef:
    var ptr_value: Pointer[Int]
    var ptr_ref_count: Pointer[Int]

    fn __init__(inout self, value: Int):
        self.ptr_value = Pointer[Int].alloc(1)
        self.ptr_value.store(0, value)
        self.ptr_ref_count = Pointer[Int].alloc(1)
        self.ptr_ref_count.store(0, 1)

    fn __copyinit__(inout self, borrowed existing: Self):
        print("__copyinit__")
        self.ptr_value = existing.ptr_value
        self.ptr_ref_count = existing.ptr_ref_count
        self._incref()

    fn __moveinit__(inout self, owned existing: Self):
        print("__moveinit__")
        self.ptr_value = existing.ptr_value
        self.ptr_ref_count = existing.ptr_ref_count

    fn _incref(inout self):
        let ref_count = self.ptr_ref_count.load(0)
        self.ptr_ref_count.store(0, ref_count + 1)

    fn _decref(inout self):
        let ref_count = self.ptr_ref_count.load(0)
        self.ptr_ref_count.store(0, ref_count -1)

    fn __del__(owned self):
        self._decref()
        let ref_count = self.ptr_ref_count.load(0)
        if ref_count == 0:
            print("Data freed")
            self.ptr_value.free()
            self.ptr_ref_count.free()

    fn __str__(self) -> String:
        let ref_count = self.ptr_ref_count.load(0)
        let value = self.ptr_value.load(0)
        return "Ref(value=" + String(value) + ', ref_count=' + String(ref_count) + ")"

    fn set_value(inout self, value: Int):
        self.ptr_value.store(0, value)

[rd4com]

good job, it is quite cool 🔥

You might need to be extra thoughtful with tensors in that specific use case:
I believe but i am not really sure that they own their data, so calling ___del()__ on one them would free it!

Again, not sure !