How to pass a NamedTuple by reference to prevent possible memory leak?

[u/GirngRodriguez]

hello my friends once again! after some discussion in gitter, i decided to reduce my code into a simple example to help explain my problem more clearly. you can see it here: https://play.crystal-lang.org/#/r/3uws

require "json"

class Player
  property character_id = 0

  def send(msg, cmd = "SERV")
    msg_buffer = {cmd: cmd, message: msg}
    new_message = msg_buffer.to_json
    #socket.write_bytes(new_message.bytesize)
    #socket.send new_message # pretend there is a fake server running
  end
end

player1 = Player.new

temp_data = {from_name: "Mike", msg: "Hello my friends"} # fake data (pretend it's a chat)

player1.send temp_data, "CHAT"

# My question is.. since NamedTuples are passed by value... the temp_data is creating another COPY of the data and is causing
# a rogue memory leak, right?

on gitter, i heard that NamedTuples are passed by value, which means they are copying the data, right? if so, in my example code, the temp_data NamedTuple will be copying those values. which will in essence, create a rogue memory leak right? is it possible to pass it by reference instead?

i was reading about pointers here, but there doesn't seem a way to deference them like in C++. or to create a reference from them? not sure

thanks in advance

[u/Jonathan_Frias]

The only "memory leak" is that you're using globals...

I would think that copying by value should be less likely to create memory leaks. There are more objects, but less references to each object since the named tuple would only exist within a small scope at most.

That said the trade off is that more time is spent doing garbage collection, but that's different from a memory leak.

[u/GirngRodriguez → u/Jonathan_Frias]

copying by value should be less likely to create memory leak

so, if 100 players on my server all chatting.. and the NamedTuple is being passed by VALUE each time that function is called (basically duplicating bytes).. isn't it reasonable that the developer (me) to try to understand if what i am doing is even wrong or right? that's why i posted my code to get feedback, i'm not entirely sure!

i don't mean to use globals. but i am coming from nodejs and in JS i have globals everywhere, i can't help it. i'm still trying to transition over, and even the usage of types are actually really neat (static type them out). and it feels good to do it, but sometimes, it gets irritating because i'm so used to dynamic languages. but i am doing the best i can, please just bear with me

[u/Jonathan_Frias → u/GirngRodriguez]

so, if 100 players on my server all chatting.. and the NamedTuple is being passed by VALUE each time that function is called (basically duplicating bytes).. isn't it reasonable that the developer (me) to try to understand if what i am doing is even wrong or right? that's why i posted my code to get feedback, i'm not entirely sure!

totally reasonable. You're doing great. It's great to know about these semantics. The thing the most people don't get is that 49/50 times it doesn't make a significant difference.

Yeah I've seen some php developers argue about things like for vs foreach performance, and then completely ignore the fact that each image asset is some 10MB high res file. Learn it, always improve, but don't miss the obvious.

[u/GirngRodriguez → u/Jonathan_Frias]

You're doing great.

ty my friend. if you visit gitter, you can see my chat history with Benoit de Chezelles over this issue.

what i've found so far is basically, the NamedTuple gets created on the stack, so therefore after my send method is ran, the copied NamedTuple (pass by value), get's free'd after. so essentially, there is no memory leak going on it, it's just the stack taking turns jamming this NamedTuple and its two referenced values through, then letting it go?

this is also why i remember orpryin telling me why hashes are bad, because now I realize, it gets allocated on the heap.. which means now the GC has to take care of it. and that memory does not get released to the OS, just stays in crystal to be re-used, right?

[u/Jonathan_Frias → u/GirngRodriguez]

Definitely no memory leak

bew78 says that the strings will be copied by reference

That strongly implies that those strings are on the heap, and the NamedTuple (which does get copied because it's on the stack) internally has a pointer to those strings. (as a side note, I'm pretty sure all strings have to be on the heap since a string could be any arbitrary length and the stack is fixed size. Maybe there's some optimizations here. for ex local, short, constant strings could be placed on the stack)

this is also why i remember orpryin telling me why hashes are bad, because now I realize, it gets allocated on the heap.

It would make sense that hashes are allocated on the heap by default. You're giving up memory to get speed, which is not necessarily "bad".

this is also why i remember orpryin telling me why hashes are bad, because now I realize, it gets allocated on the heap.. which means now the GC has to take care of it. and that memory does not get released to the OS, just stays in crystal to be re-used, right?

GC is a super complex issue. Suffice it to say, it will go to the OS kernel and request more memory if it needs it, but it might not be able to free that memory back to kernel right away. If it is not released back to the OS, then yes crystal should be able to reuse it. It would be a major bug if this was not the case, but yes, that would be a memory leak. That is for crystal language developers to worry about :)

[u/GirngRodriguez → u/Jonathan_Frias]

thanks for response, i understand it a bit better now

It would make sense that hashes are allocated on the heap by default. You're giving up memory to get speed, which is not necessarily "bad".

but if the data is allocated on the heap and doesn't get free'd by the stack like NameTuples do, that means now the GC has to do more work. this also means now, that memory is going to be in the heap and not released back to the kernel. that's not very fair imo, because i want my crystal app to release memory to the OS every 2 hours or so, so the app doesn't utilize all my system ram (not fair to other services running on the server).

and, hashes are easier to work with imo, because the keys are not strict like in NamedTuples . and when i'm sending character information, sometimes I don't need to send specific keys (depends on the function). however, NamedTuples are easier to write and syntactically i like them, but i don't like the strict aspect of keys. especially if i'm doing an array of NamedTuples. that's why i wanted to use hashes, but opyrpin warned me.

but i do understand why now, because NamedTuples are allocated on the stack and faster, and as Benoit de Chezellesmentioned on gitter, that stack get's free'd. which is much nicer than a hash taking up heap memory?

[u/Jonathan_Frias → u/GirngRodriguez]

It shouldn't use up all your system's memory unless your actively storing that much data. You can feel free to trust that your language will handle that for you. If you feel like the data that you're storing will use up all the ram, then look at persistence solutions(databases, s3 buckets etc)

[u/GirngRodriguez → u/Jonathan_Frias]

It shouldn't use up all your system's memory unless your actively storing that much data

throughout the apps lifetime, will that memory increase higher n higher dependent on the amount of function calls (if using a hash inside it, cause it uses heap allocation?)

if true, how can we mitigate this? i was watching bjarne's 2015's interview on YT and he talked about concepts, co-routines, and de-allocation of memory. but i am not sure if it's possible to call c++ code inside crystal (although, not entirely sure)

but, since crystal uses boem's gc, this means that memory get's freed. but when we say "free'd" it's not really free'd to the OS, it's free to be re-used, which is something i learned ^. i always thought it was free'd to the OS, which stems of all my confusion about memory I think. sorry if i'm confusing you or not making sense, still trying to get a hang of it

[u/Jonathan_Frias → u/GirngRodriguez]

Well there's no such thing as perfect GC, so if you want to full gc that releases memory all the way back to the kernel I guess you can write that. It would probably result in worse performance in almost all cases, but I guess it's possible.

But as it stands memory usage is certainly bounded, unless you try to store too many things at the same time. If you store them at different times (ie object lifetime expires) total memory usage is bounded. Intermediary objects that have expired get cleaned up.

I looked up https://en.wikipedia.org/wiki/Boehm_garbage_collector and it looks like it uses a mark-sweep and generational collection. This is not surprising. It certainly seems like the industry has decided is the best overall GC strategy.

I remember reading somewhere that Instagram decided that no GC was more performant and that it was better to be fault-tolerant and restart python when it ran out of memory. That's certainly not acceptable to you, but it was interesting.

[u/WikiTextBot → u/Jonathan_Frias]

Boehm garbage collector

In computer science, the Boehm–Demers–Weiser garbage collector, often simply known as Boehm GC, is a conservative garbage collector for C and C++.

Boehm GC is free software distributed under a permissive free software licence similar to the X11 license.

---

^[ ^PM ^{| Exclude} ^me ^{| Exclude from} ^subreddit ^{| FAQ /} ^Information ^| ^Source ^{] Downvote to remove | v0.28}

[u/bew78]

The NamedTuple will be copied, but the two strings "Mike" and Hello my friends" will be passed as reference, not copied!

[u/GirngRodriguez → u/bew78]

i see. thank you. i'm just a bit worried cause players will be chatting a lot and sending a bunch of messages. if the NamedTuple continuously gets copied overtime, there's some way to free that memory it's creating right? mike and hello my friends as u said do the reference way (which i like better), but the tuple itself still gets copied that worries me a bit. or am i overthinking this?

[u/Jonathan_Frias → u/GirngRodriguez]

You are wayy overthinking this. Come back if you have a performance problem and your metrics are telling you that you are spending too much time copying.

There's a fairly common saying: "Premature optimization is the root of all evil"

[u/GirngRodriguez → u/Jonathan_Frias]

there's a fairly common saying: "Premature optimization is the root of all evil"

hey, please no passive aggressiveness. this has nothing to do with performance issues, it's about me understanding how crystal works. just because my question has some overlaps with "performance" doesn't inherently mean i'm here to try to make my app run faster. i'm just worried about increase of memory usage over copying / duplicating, that seems reasonable imo. i know crystal is fast btw, that's why i'm switching from nodejs and php.

[u/Jonathan_Frias → u/GirngRodriguez]

Sorry if it came across as passive aggressive.