When I am able to use an object pool I don't really rely on the GC and don't really need weak references either.   In one real-time application, I cycle through ~ 9 billion objects over the course of a few hours.   The working set in this scenario is small.<div>
<br></div><div>In the application I was testing with sgen, it is a batch oriented process, not real-time.  Hence I rely on the GC in that case.    For latency sensitive work am largely using object pools for the objects used at high frequency and some structs where appropriate. <br>
<br><div class="gmail_quote">On Mon, Sep 3, 2012 at 8:18 AM, Nicholas Frechette <span dir="ltr"><<a href="mailto:zeno490@gmail.com" target="_blank">zeno490@gmail.com</a>></span> wrote:<br><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">
Have you thought about using weak pointers? Those are already handled<br>
as a special case by the GC.<br>
In your pool, you keep weak references such that if a GC happens and<br>
no real references exist on an object outside of weak references, the<br>
object will be GCed and all weak references will be invalidated. In<br>
the event that a real reference exists, nothing changes.<br>
<br>
Then in your pool you can check for any invalidated entries and reuse<br>
those, you could trigger a GC manually in hope of freeing some or you<br>
could allocate new ones. As you see fit.<br>
<br>
Implementing a cache isn't very hard and I believe some might already<br>
exist in .net (using more or less what I just described).<br>
<br>
In .net, weak references are called: System.WeakReference.<br>
<br>
As discussed above, a cache like this mostly only makes sense if the<br>
allocation cost is very large or if you want a maximum fixed amount of<br>
objects allocated.<br>
<br>
Cheers,<br>
Nicholas<br>
<br>
On Fri, Aug 31, 2012 at 7:45 PM, Jonathan Shore<br>
<div class="HOEnZb"><div class="h5"><<a href="mailto:jonathan.shore@gmail.com">jonathan.shore@gmail.com</a>> wrote:<br>
><br>
> On Aug 31, 2012, at 7:39 PM, Rodrigo Kumpera wrote:<br>
><br>
> Unless you use explicit memory management or some other trick, such scheme<br>
> is not any better than what both collectors already do.<br>
><br>
> Both use a size-segregated allocator for the major heap which works very<br>
> much like an object pool based on size.<br>
><br>
> Object pools work when allocating memory is very expensive. With an modern<br>
> GC, the major cost is not allocation, but tracing.<br>
><br>
><br>
> I guess I'm searching for some solution that is at least as good as boehm<br>
> for my working set, but without the current memory size limitations.<br>
><br>
> I achieve much better performance when using object pools, of course because<br>
> of the explicit object release, avoiding the cost of tracing.<br>
><br>
><br>
><br>
> On Fri, Aug 31, 2012 at 8:18 PM, Jonathan Shore <<a href="mailto:jonathan.shore@gmail.com">jonathan.shore@gmail.com</a>><br>
> wrote:<br>
>><br>
>> I use object pools where I have control over the lifecycle of objects used<br>
>> with high frequency.    In the application I was discussing with respect to<br>
>> sgen, it is very hard to explicitly use object pools (nor can I use structs<br>
>> in this case).<br>
>><br>
>> I think Miguel mentioned briefly in a blog, but would be interesting to<br>
>> have a non-MS compatible extension or special Mono namespace library /<br>
>> runtime support for automatic object pooling.    I have a number of<br>
>> applications that need to deal with billions of objects cycled through.<br>
>> Instead of bending over backwards to try to fit in an explicit ObjectPool<br>
>> model, would love to be able to designate a maximum fixed size pool that<br>
>> would be handled as a special case by the GC:<br>
>><br>
>> whenever new <someobject> () is invoked, the runtime will attempt to pull<br>
>> from an existing object in pool<br>
>><br>
>> if the pool is full, a GC sweep is done to determine whether any of the<br>
>> objects / slots in the pool are now garbage, perhaps compacting or just<br>
>> marking.<br>
>><br>
>> when an object becomes garbage, nothing explicit happens, is only marked &<br>
>> reused on the next new.<br>
>><br>
>><br>
>> I realize this is not part of the MS CLR spec, but is *very* useful for<br>
>> all sorts of high throughput services and processing.   It seems like a much<br>
>> simplified form of what sgen or beohm would be doing.<br>
>><br>
>> Thoughts?<br>
>><br>
>> Jonathan<br>
>><br>
>><br>
>><br>
>> _______________________________________________<br>
>> Mono-devel-list mailing list<br>
>> <a href="mailto:Mono-devel-list@lists.ximian.com">Mono-devel-list@lists.ximian.com</a><br>
>> <a href="http://lists.ximian.com/mailman/listinfo/mono-devel-list" target="_blank">http://lists.ximian.com/mailman/listinfo/mono-devel-list</a><br>
>><br>
><br>
><br>
><br>
> _______________________________________________<br>
> Mono-devel-list mailing list<br>
> <a href="mailto:Mono-devel-list@lists.ximian.com">Mono-devel-list@lists.ximian.com</a><br>
> <a href="http://lists.ximian.com/mailman/listinfo/mono-devel-list" target="_blank">http://lists.ximian.com/mailman/listinfo/mono-devel-list</a><br>
><br>
</div></div></blockquote></div><br><br clear="all"><div><br></div>-- <br>Jonathan Shore<br><a href="http://tr8dr.wordpress.com/">http://tr8dr.wordpress.com/</a><br>
</div>