Hello...
Read this:
What about garbage collection?
Read what said this serious specialist called Chris Lattner:
"One thing that I don’t think is debatable is that the heap compaction behavior of a GC (which is what provides the heap fragmentation win) is incredibly hostile for cache (because it cycles the entire memory space
of the process) and performance predictability."
"Not relying on GC enables Swift to be used in domains that don’t want
it - think boot loaders, kernels, real time systems like audio
processing, etc."
"GC also has several *huge* disadvantages that are usually glossed over:
while it is true that modern GC's can provide high performance, they can
only do that when they are granted *much* more memory than the process
is actually using. Generally, unless you give the GC 3-4x more memory
than is needed, you’ll get thrashing and incredibly poor performance. Additionally, since the sweep pass touches almost all RAM in the
process, they tend to be very power inefficient (leading to reduced
battery life)."
Read more here:
https://lists.swift.org/pipermail/swift-evolution/Week-of-Mon-20160208/009422.html
Here is Chris Lattner's Homepage:
http://nondot.org/sabre/
And here is Chris Lattner's resume:
http://nondot.org/sabre/Resume.html#Tesla
This why i have invented the following scalable algorithm and its implementation that makes Delphi and FreePascal more powerful:
My invention that is my scalable reference counting with efficient
support for weak references version 1.38 is here..
Here i am again, i have just updated my scalable reference counting with efficient support for weak references to version 1.37, I have just added
a TAMInterfacedPersistent that is a scalable reference counted version,
and now i think i have just made it complete and powerful.
Because I have just read the following web page:
https://www.codeproject.com/Articles/1252175/Fixing-Delphis-Interface-Limitations
But i don't agree with the writting of the guy of the above web page,
because i think you have to understand the "spirit" of Delphi, here is why:
A component is supposed to be owned and destroyed by something else, "typically" a form (and "typically" means in english: in "most" cases,
and this is the most important thing to understand). In that scenario, reference count is not used.
If you pass a component as an interface reference, it would be very
unfortunate if it was destroyed when the method returns.
Therefore, reference counting in TComponent has been removed.
Also because i have just added TAMInterfacedPersistent to my invention.
To use scalable reference counting with Delphi and FreePascal, just
replace TInterfacedObject with my TAMInterfacedObject that is the
scalable reference counted version, and just replace
TInterfacedPersistent with my TAMInterfacedPersistent that is the
scalable reference counted version, and you will find both my TAMInterfacedObject and my TAMInterfacedPersistent inside the AMInterfacedObject.pas file, and to know how to use weak references
please take a look at the demo that i have included called example.dpr
and look inside my zip file at the tutorial about weak references, and
to know how to use delegation take a look at the demo that i have
included called test_delegation.pas, and take a look inside my zip file
at the tutorial about delegation that learns you how to use delegation.
I think my Scalable reference counting with efficient support for weak references is stable and fast, and it works on both Windows and Linux,
and my scalable reference counting scales on multicore and NUMA systems,
and you will not find it in C++ or Rust, and i don't think you will find
it anywhere, and you have to know that this invention of mine solves
the problem of dangling pointers and it solves the problem of memory
leaks and my scalable reference counting is "scalable".
And please read the readme file inside the zip file that i have just
extended to make you understand more.
You can download my new scalable reference counting with efficient
support for weak references version 1.38 from:
https://sites.google.com/site/scalable68/scalable-reference-counting-with-efficient-support-for-weak-references
Thank you,
Amine Moulay Ramdane.
--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)