C#•2d ago

Maybe the case for object pooling?

I have a large array I am processing. Each item is a large object that has multiple processors (classes with state). Creating those 10 for example proccessors for every item in the list will be expensive. Should I use something like object pooling? So I create the processor once and reuse it using a reset pattern? What's the best way to handle it? Also maybe there is a better alternative to classes altogethe?

9 Replies

Anton•2d ago

2 options: - pool; - use structs and ids instead of references, look up in the array when you need to update a processor. You only need any of these if you're going to be creating new processors often A pool + reset (also called flyweight) is how people usually do it You have no way around having a large amount of fields if you need a large amount of fields, unless the problem allows one to redesign it in a way where you don't.

AllMightOP•2d ago

@Anton mind sharing a simple code example? I know object pool exists but only saw it used with buffers. Never actually worked with structs to be honest so I am not sure I understand I am generally not sure how best to process a big object with many logics on it which is part of a really large array

Anton•2d ago

using System;
using System.Collections.Generic;

public readonly struct ResetParams
{
    // presumably lots of stuff needed on creation
}

public readonly struct Dependencies
{
    // things passed on creation, but not on reset
}

public sealed class YourObject {
    // lots of fields
    
    public YourObject(Dependencies deps)
    {
        // ...
    }
    
    // using `in` because I'm assuming it's big.
    // if the reset is async, you can pool these too if they're big.
    public void Reset(in ResetParams p)
    {
        // ...
    }
}

public sealed class Pool 
{
    // You may need to access these under a lock if you're accessing
    // these from multiple threads.
    private readonly List<YourObject> _unused = new();

    // Can loop through these to do some processing for all objects
    // if needed.
    private readonly HashSet<YourObject> _inUse = new();
    
    // This can be a factory function instead if you want to
    // make your pool class more generic.
    private readonly Dependencies _deps;
    
    public Pool(Dependencies deps)
    {
        _deps = deps;
    }
    
    public YourObject Create(in ResetParams p)
    {
        YourObject ret;
        if (_unused.Count == 0)
        {
            ret = new YourObject(_deps);
        }
        else
        {
            int lastIndex = _unused.Count - 1;
            ret = _unused[lastIndex];
            _unused.RemoveAt(lastIndex);
        }

        ret.Reset(p);
        _inUse.Add(ret);
        return ret;
    }

    public void Return(YourObject obj)
    {
        bool removed = _inUse.Remove(obj);
        Debug.Assert(removed);

        _unused.Add(obj);
    }
}

using System;
using System.Collections.Generic;

public readonly struct ResetParams
{
    // presumably lots of stuff needed on creation
}

public readonly struct Dependencies
{
    // things passed on creation, but not on reset
}

public sealed class YourObject {
    // lots of fields
    
    public YourObject(Dependencies deps)
    {
        // ...
    }
    
    // using `in` because I'm assuming it's big.
    // if the reset is async, you can pool these too if they're big.
    public void Reset(in ResetParams p)
    {
        // ...
    }
}

public sealed class Pool 
{
    // You may need to access these under a lock if you're accessing
    // these from multiple threads.
    private readonly List<YourObject> _unused = new();

    // Can loop through these to do some processing for all objects
    // if needed.
    private readonly HashSet<YourObject> _inUse = new();
    
    // This can be a factory function instead if you want to
    // make your pool class more generic.
    private readonly Dependencies _deps;
    
    public Pool(Dependencies deps)
    {
        _deps = deps;
    }
    
    public YourObject Create(in ResetParams p)
    {
        YourObject ret;
        if (_unused.Count == 0)
        {
            ret = new YourObject(_deps);
        }
        else
        {
            int lastIndex = _unused.Count - 1;
            ret = _unused[lastIndex];
            _unused.RemoveAt(lastIndex);
        }

        ret.Reset(p);
        _inUse.Add(ret);
        return ret;
    }

    public void Return(YourObject obj)
    {
        bool removed = _inUse.Remove(obj);
        Debug.Assert(removed);

        _unused.Add(obj);
    }
}

If you're worried about returned references hanging around in the program, you may add some safeguards Like this maybe

using System;
using System.Collections.Generic;

internal sealed class PoolItem
{
    public YourObject Value { get; init; }
    public int Version { get; private set; }

    public void NextVersion()
    {
        Version++;
    }

    public YourObjectHandle Handle()
    {
        return new()
        {
            Item = this,
            Version = Version,
        };
    }
}

public readonly struct YourObjectHandle
{
    internal PoolItem Item { get; init; }
    internal int Version { get; init; }

    internal YourObjectHandle()
    {
    }

    public YourObject Value
    {
        get
        {
            Debug.Assert(Version == Item.Version, "Using already destroyed object");
            return Item.Value;
        }
    }
}

public sealed class Pool 
{
    private readonly List<PoolItem> _unused = new();
    private readonly HashSet<PoolItem> _inUse = new();
    private readonly Dependencies _deps;
    
    public Pool(Dependencies deps)
    {
        _deps = deps;
    }
    
    public YourObjectHandle Create(in ResetParams p)
    {
        PoolItem ret;
        if (_unused.Count == 0)
        {
            var obj = new YourObject(_deps);
            ret = new PoolItem(obj);
        }
        else
        {
            int lastIndex = _unused.Count - 1;
            ret = _unused[lastIndex];
            _unused.RemoveAt(lastIndex);
        }

        ret.Value.Reset(p);

        _inUse.Add(ret);

        return ret.Handle();
    }

    public void Return(YourObjectHandle h)
    {
        var item = h.Item;

        bool removed = _inUse.Remove(item);
        Debug.Assert(removed);

        item.NextVersion();

        _unused.Add(item);
    }
}

using System;
using System.Collections.Generic;

internal sealed class PoolItem
{
    public YourObject Value { get; init; }
    public int Version { get; private set; }

    public void NextVersion()
    {
        Version++;
    }

    public YourObjectHandle Handle()
    {
        return new()
        {
            Item = this,
            Version = Version,
        };
    }
}

public readonly struct YourObjectHandle
{
    internal PoolItem Item { get; init; }
    internal int Version { get; init; }

    internal YourObjectHandle()
    {
    }

    public YourObject Value
    {
        get
        {
            Debug.Assert(Version == Item.Version, "Using already destroyed object");
            return Item.Value;
        }
    }
}

public sealed class Pool 
{
    private readonly List<PoolItem> _unused = new();
    private readonly HashSet<PoolItem> _inUse = new();
    private readonly Dependencies _deps;
    
    public Pool(Dependencies deps)
    {
        _deps = deps;
    }
    
    public YourObjectHandle Create(in ResetParams p)
    {
        PoolItem ret;
        if (_unused.Count == 0)
        {
            var obj = new YourObject(_deps);
            ret = new PoolItem(obj);
        }
        else
        {
            int lastIndex = _unused.Count - 1;
            ret = _unused[lastIndex];
            _unused.RemoveAt(lastIndex);
        }

        ret.Value.Reset(p);

        _inUse.Add(ret);

        return ret.Handle();
    }

    public void Return(YourObjectHandle h)
    {
        var item = h.Item;

        bool removed = _inUse.Remove(item);
        Debug.Assert(removed);

        item.NextVersion();

        _unused.Add(item);
    }
}

AllMightOP•2d ago

Well I got a bit lost tbh. Maybe if I explain better it will match more what I am doing. Each item I am processing is large (with nested large arrays too) so I iterate over it once and apply logics. Each logic is a class The problem is creating those classes for every item I am processing When I have many items The classes themselves are small (methods and some state)

Anton•2d ago

well you can separate out data per item and the processors only store data per item and a reference to the processor that takes that data as a parameter This will allow you to not have to store a whole separate processor for each item But have a singleton processor and only store a reference to it, or not store a reference at all and get it from some other context Depending on the problem, an ECS might help

AllMightOP•2d ago

@Anton ye sounds good. Make the proccessor singleton and only create a data object per item. I guess use pooling or struct for this data object right?

Anton•this hour

if you need to

AllMightOP•this hour

Well I am not sure haha It means allocating for every item That's why I asked

Anton•this hour

the best way to allocate objects is to either not allocate, or allocate and later deallocate them all at once spend time on this issue if your program actually consumes too much memory because it's going to take some effort and make the code surface you have to maintain larger

Gaming

Programming

Maybe the case for object pooling?

Did you find this page helpful?