Haha!
I was expecting you or @carnival (sorry, don't know the name) to respond.
Been following your issues/PRs as they are quite interesting to read!
Those results are quite surprising! I was expecting the GC to perform far
worse than that in comparison. You have successfully scratched my itch
I haven't tested the new generational GC so this may all be moot but:
I had a recent thought. Wouldn't a manual free method that frees the object
and tells the GC that it this object doesn't exist anymore be useful in
some cases?
I can imagine anywhere where you have temporary objects allocated
On Sat, Aug 1, 2015 at 5:10 PM, Michael Louwrens
michael.w.louwr...@outlook.com wrote:
I haven't tested the new generational GC so this may all be moot but:
I had a recent thought. Wouldn't a manual free method that frees the object
and tells the GC that it this object doesn't exist anymore be
I'd say that manual memory management is usually going to be faster than GC
unless you have really bad manual management and a very good GC. The best a
good GC can hope for is to be close to manual management. That's one of the
reasons the majority of systems software is still in C/C++ (memory
On Monday, May 11, 2015 at 10:03:20 PM UTC, Michael Louwrens wrote:
I am starting to read Region-Based Memory Management for a
Dynamically-Typed Language
http://link.springer.com/content/pdf/10.1007/b102225.pdf#page=240 it
proposes a second inference system, region inference.
if you take each heap region and give them their own garbage collector and
assign each thread/proces/fiber one, then you get another somewhat
related approach for soft real time performance in GC'd languages (it's
both for performance and safety parallelism) like you have in
Erlang/Elixir
On Tuesday, December 16, 2014 at 10:24:08 PM UTC+1, Stefan Karpinski wrote:
I would love to figure out a way to bring the kind of automatic resource
and memory release that Rust has to Julia, but the cost is some fairly
finicky static compiler analysis that is ok for Rust's target
Isn't that similar to smart pointers/automatic resource management in C++?
On Tuesday, December 16, 2014 at 10:24:08 PM UTC+1, Stefan Karpinski wrote:
I would love to figure out a way to bring the kind of automatic resource
and memory release that Rust has to Julia, but the cost is some
Rust isn't the only language to use such ideas. Basically it's region based
memory
management http://en.wikipedia.org/wiki/Region-based_memory_management.
Real time Java uses this. For a recent development next to Rust, check out
ParaSail https://forge.open-do.org/plugins/moinmoin/parasail/.
I guess you can approximate/emulate the region based memory management in a
GC'd language by dividing the heap into many small region and run GC over
all these regions regularly. That's what the G1 GC in Java does and see
also Azul Zing for soft real time high performance Java.
On Monday, May
I am starting to read Region-Based Memory Management for a
Dynamically-Typed Language
http://link.springer.com/content/pdf/10.1007/b102225.pdf#page=240 it
proposes a second inference system, region inference.
I will read it fully in the morning but just scanning through
their results they
No, there hasn't been any change on this. It's unclear if anything from the
Rust model can actually be leveraged in a dynamic language.
On May 9, 2015, at 3:46 PM, Michael Louwrens michael.w.louwr...@outlook.com
wrote:
Have you had any further thought on this? It seems like it could be
Have you had any further thought on this? It seems like it could be quite
useful for the cases where one intentionally disables the GC for
performance reasons - though you guys are incredibly busy! I also read
about having the compiler automatically insert frees where it can in Julia
and was
I would love to figure out a way to bring the kind of automatic resource
and memory release that Rust has to Julia, but the cost is some fairly
finicky static compiler analysis that is ok for Rust's target demographic
but fairly clearly unacceptable for Julia general audience. What we'd need
is a
This is taking the thread off-topic, but conceptually such things are possible.
But Rust has a very different set of semantics for memory ownership than Julia
has and is doing a lot more analysis at compile-time than Julia is doing. So
Julia would need to change a lot to be more like Rust. I've
15 matches
Mail list logo
