К>+ в чём "громадные потери" и кто их мерял и как? Звучит как очередное голословное утверждение, которые уже сильно утомляют. Или потери за счёт оверхэда?

void Calculate()
{
  byte[] tmpArray = new byte[N];
  ....
  ....
  ....
}

PROCEDURE Calculate;
  VAR tmpArray: ARRAY N OF BYTE;
BEGIN
  ...
  ...
  ...
END Calculate;

void Calculate()
{
  int[] tmp = new int[100];
  ...
}

PROCEDURE Calculate;
  VAR tmp: ARRAY 100 OF INTEGER;
BEGIN
  ...
END Calculate;

namespace TestLocalArray
{
    sealed class Object
    {
        const int N = 100;
        System.Threading.Thread thread;
        int count;

//              global
//        int[] histogram = new int[N];

        public int Count {get{return this.count;}}

        int Calculate()
        {
//                      clear global array
//            System.Array.Clear(this.histogram, 0, this.histogram.Length);

//                      local array
            int[] histogram = new int[N];
            for(int i = 0; i < histogram.Length; i++)
            {
                histogram[i]++;
            }
            int result = 0;
            for(int i = 0; i < histogram.Length; i++)
            {
                result += histogram[i];
            }
            return result;
        }

        void Activity()
        {
            try
            {
                while(true)
                {
                    int x = this.Calculate();
                    this.count++;
                    System.Threading.Thread.Sleep(0);
                }
            }
            catch(System.Threading.ThreadAbortException)
            {
                return;
            }
        }

        public Object()
        {
            this.thread = new System.Threading.Thread(new System.Threading.ThreadStart(this.Activity));
        }

        public void Start()
        {
            this.thread.Start();
        }

        public void Stop()
        {
            if(this.thread != null)
         {
            this.thread.Abort(null);
            this.thread = null;
         }
        }
    }

    class Program
    {
        conts int M = 500;
        Object[] objects = new Object[M];
        void Run()
        {
            System.Console.WriteLine("Program started");
            for(int i = 0; i < this.objects.Length; i++) { this.objects[i] = new Object(); }
            System.Console.WriteLine("objects created");
            for(int i = 0; i < this.objects.Length; i++) { this.objects[i].Start(); }
            System.Console.WriteLine("threads running");
            System.Console.WriteLine("sleep 15 seconds...");
            System.Threading.Thread.Sleep(15000);
            for(int i = 0; i < this.objects.Length; i++) { this.objects[i].Stop(); }
            System.Console.WriteLine("threads stopped");
            long result = 0;
            for(int i = 0; i < this.objects.Length; i++)
            {
                result += this.objects[i].Count;
            }
            System.Console.WriteLine("result = {0}", result);
            System.Console.WriteLine("Program stopped.");
        }

        static void Main(string[] args)
        {
            Program p = new Program();
            p.Run();
            System.Console.ReadLine();
        }
    }
}

class SomeClass
{
}

PROCEDURE Calculate;
  VAR tmp: ARRAY 3 OF BYTE;
BEGIN
  ...
END Calculate;

O>Тот код, что привели вы, совершенно не показывает преимуществ обожествляемого вами Оберона, он сравнивает C# с ... правильно, с C#! Причём указывает на совершенно очевидную вещь — не выделять память каждый раз получается быстрее, чем выделять её. Кстати, в случае массива на стеке её всё равно пришлось бы выделять (на стеке), так что пример как минимум некорректен — мы так и не увидели, насколько выделение массива на стеке быстрее оного из managed heap.

O>Зато с полезностью пулов вроде как сами согласились

СГ>PROCEDURE Calculate;
СГ>  VAR tmp: ARRAY 3 OF BYTE;
СГ>BEGIN
СГ>  ...
СГ>END Calculate;
СГ>

O>>Тот код, что привели вы, совершенно не показывает преимуществ обожествляемого вами Оберона, он сравнивает C# с ... правильно, с C#! Причём указывает на совершенно очевидную вещь — не выделять память каждый раз получается быстрее, чем выделять её. Кстати, в случае массива на стеке её всё равно пришлось бы выделять (на стеке), так что пример как минимум некорректен — мы так и не увидели, насколько выделение массива на стеке быстрее оного из managed heap.

O>>Зато с полезностью пулов вроде как сами согласились

а) Либо написать компилятор моего любимого оберона под дотнет, но тогда я: 1) потеряю чисто оберонистые библиотеки исходников которых у меня нет; 2) заработаю огромадные потери производительности, так как дотнетская вычислительная модель (или как там это назвать) "слабее" чем оберонистая (в дотнете нет нормальных value-типов, массивов, вложенных процедур).

array<int>^ f()
{
    array<int> a(10); // создали массив в стеке -- в настоящее время невозможно
    . . .
    return a;         // при желании вернули, массив "забоксился"
}

int^ f()
{
    int i = 10; // создали целое в стеке
    . . .
    return i;   // вернули, оно "забоксилось"
}

struct V
{
    int x;
    int y;
    int z;
}
. . .
V v = new V();

int[] a = new int[3];

class SomeClass
{
}

PROCEDURE P;
  VAR a: ARRAY 3 OF BYTE;
BEGIN
  ...
END P;

PROCEDURE Calculate(a: ARRAY OF BYTE; IN b: ARRAY OF BYTE; VAR c: ARRAY OF BYTE; OUT d: ARRAY OF BYTE);

PROCEDURE Calculate(pa: POINTER TO ARRAY OF BYTE;
  VAR pc: POINTER TO ARRAY OF BYTE; OUT pd: POINTER TO ARRAY OF BYTE);