Сжатие памяти в управляемой среде

Ответ 1

Я сочувствую вашей ситуации; когда я работал над Roslyn, мы очень тщательно рассмотрели потенциальные проблемы с производительностью, вызванные давлением сбора из распределения временных рабочих массивов. Решение, на котором мы остановились, было стратегией объединения.

В компиляторе размеры массива имеют тенденцию быть небольшими и поэтому часто повторяются. В вашей ситуации, если у вас большие массивы, то то, что я сделаю, следует за предложением Тома: упростите проблему управления и потратите некоторое пространство. Когда вы задаете пул для массива размера x, округлите x до ближайшей мощности двух и выделите массив этого размера или возьмите один из пула. Вызывающий получает массив, который немного велик, но их можно написать, чтобы справиться с этим. Не следует слишком сложно искать пул для массива соответствующего размера. Или вы можете поддерживать пул пулов, один пул для массивов размером 1024, один для 2048 и т.д.

Написание пула потоков не слишком сложно, или вы можете сделать поток пула статическим и иметь один пул на поток.

Сложный бит возвращает память в пул. Есть несколько способов справиться с этим. Во-первых, вы можете просто потребовать от пользователя объединенной памяти вызвать метод "обратно в пул", когда они будут сделаны с массивом, если они не хотят брать на себя расходы на сбор.

Другой способ - написать оболочку фасада вокруг массива, сделать его реализацией IDisposable, чтобы вы могли использовать "использование" (*) и сделать финализатор на том, что помещает объект обратно в пул, воскрешая его. (Удостоверьтесь, что финализатор вернется к бит "Я должен быть доработан".) Финализаторы, которые делают воскрешение, заставляют меня нервничать; Я лично предпочел бы прежний подход, что мы и сделали в Рослине.

(*) Да, это нарушает принцип, согласно которому "использование" должно указывать на то, что неуправляемый ресурс возвращается в операционную систему. По сути, мы рассматриваем управляемую память как неуправляемый ресурс, делая свое собственное управление, поэтому это не так уж плохо.

Ответ 2

Вы можете обернуть код, который использует тезисы массивов царапин в операторе using следующим образом:

using(double[] scratchArray = new double[buffer])
{
    // Code here...
}

Это освободит память явным образом, вызвав дескриптор в конце инструкции using.

К сожалению, похоже, что это не так! Вместо этого вы можете попробовать что-то по линии вспомогательной функции, которая возвращает массив соответствующего размера (ближайшая мощность 2 больше размера), а если он не существует, создавая его. Таким образом, у вас будет только логарифмическое количество массивов. Если вы хотите, чтобы он был потокобезопасным, хотя вам нужно будет немного потрудиться.

Он может выглядеть примерно так: (используя pow2roundup из Алгоритм для нахождения наименьшей мощности двух, более или равных заданному значению)

private static Dictionary<int,double[]> scratchArrays = new Dictionary<int,double[]>();
/// Round up to next higher power of 2 (return x if it already a power of 2).
public static int Pow2RoundUp (int x)
{
    if (x < 0)
        return 0;
    --x;
    x |= x >> 1;
    x |= x >> 2;
    x |= x >> 4;
    x |= x >> 8;
    x |= x >> 16;
    return x+1;
}
private static double[] GetScratchArray(int size)
{
    int pow2 = Pow2RoundUp(size);
    if (!scratchArrays.ContainsKey(pow2))
    {
        scratchArrays.Add(pow2, new double[pow2]);
    }
    return scratchArrays[pow2];
}

Редактировать: версия для версии: У этого все еще есть вещи, которые собирают мусор, но он будет специфичным для потока и должен быть намного меньше накладных расходов.

[ThreadStatic]
private static Dictionary<int,double[]> _scratchArrays;

private static Dictionary<int,double[]> scratchArrays
{
    get
    {
        if (_scratchArrays == null)
        {
            _scratchArrays = new Dictionary<int,double[]>();
        }
        return _scratchArrays;
    }
}

/// Round up to next higher power of 2 (return x if it already a power of 2).
public static int Pow2RoundUp (int x)
{
    if (x < 0)
        return 0;
    --x;
    x |= x >> 1;
    x |= x >> 2;
    x |= x >> 4;
    x |= x >> 8;
    x |= x >> 16;
    return x+1;
}
private static double[] GetScratchArray(int size)
{
    int pow2 = Pow2RoundUp(size);
    if (!scratchArrays.ContainsKey(pow2))
    {
        scratchArrays.Add(pow2, new double[pow2]);
    }
    return scratchArrays[pow2];
}