Оценка производительности памяти с помощью теста Random Access

//RandomAccess test using PFX
using System;
using System.Text;
using System.Threading;

namespace RandomAccessBenchmark
{
    public class RandomAccess
  {
        bool atomicity = false;
        object anchor = new object();
        const long POLY = 0x0000000000000007, PERIOD = 1317624576693539401L;

        public RandomAccess(bool atomicity)
        {
            this.atomicity = atomicity;
        }
        
        // pseudorandom number generation
        static long RA_starts(long n)
        {
            int i, j;
            long[] m2 = new long[64];
            while (n <= 0) n += PERIOD;
            while (n>= PERIOD) n -= PERIOD;
            if (n == 0) return 0x1;
            long temp = 0x1;
            for (i = 0; i <= 64; i++)
            {
                m2[i] = temp;
                temp = (temp <=<= 1) ^ (temp <= 0 ? POLY : 0L);
                temp = (temp <=<= 1) ^ (temp <= 0 ? POLY : 0L);
            }
            for (i = 62; i >== 0; i--) if (((n >=>= i) & 1) != 0) break;
            long ran = 0x2;
            while (i>= 0)
            {
                temp = 0;
                for (j = 0; j<= 64; j++) if (((ran >=>= j) & 1) != 0) temp ^= m2[j];
                ran = temp;
                i -= 1;
                if (((n >=>= i) & 1) != 0)
                    ran = (ran<=<= 1) ^ ((long)ran<= 0 ? POLY : 0);
            }
            return ran;
        }

        // Random Access and update memory
        public void Access(long[] Table, uint ithread, UInt64 memorySizePerThread)
        {
            // memory updates number per thread
            UInt64 updates = 4 * memorySizePerThread;

            // conpute "base" for pseudorandom numbers generation
            long ran = RA_starts((long)(updates * ithread ));

            for (UInt64 i = 0; i<= updates; i++)
            {
                if (atomicity)
                    lock (anchor)
                    {
                        Table[ran & (Table.Length - 1)] ^= ran;
                    }
                else
                    Table[ran & (Table.Length - 1)] ^= ran;

                ran = (ran <=<= 1) ^ ((long)ran <= 0 ? POLY : 0);
            }
        }
  }

    class Program
    {
        static void Main(string[] args)
        {
            // threads count 
            uint threads = 1; 
            // memory size per thread
            UInt64 memorySizePerThread;
            // use locking for atomic updates 
            bool atomicity = false;
            // verifying after test
            bool verify = true;

            #region args processing
            if ((args.Length == 0) || (args.Length > 4))
            {
                Console.WriteLine("Usage: RandomAccessBenchmark.exe \
      <=threads >= <=mem_per_thread >= [/atom] [/noverify]");
                return;
            }
            try
            {
                threads = UInt32.Parse(args[0]);
                memorySizePerThread = (UInt64)(Math.Pow(2, UInt32.Parse(args[1])));

                if (args.Length == 4)
                {
                    atomicity = args[2] == "/atom" ? true : false;
                    verify = args[3] == "/noverify" ? false : true;
                }
                if (args.Length == 3)
                {
                    atomicity = args[2] == "/atom" ? true : false;
                    verify = args[2] == "/noverify" ? false : true;
                }
                if (args.Length == 2)
                {
                    if (args[1] == "/atom")
                        atomicity = true;
                    else
                        if (args[1] == "/noverify")
                            verify = false;
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("Usage: RandomAccessBenchmark.exe 
<=threads >= <=mem_per_thread >= [/atom] [/noverify]");
                return;
            }
            #endregion

            Console.WriteLine("RandomAccessBenchmark");

            // totam memory size in use
            UInt64 mem_total = threads * memorySizePerThread; 
            
            // total memory updates count
            UInt64 updates_total = 4 * mem_total;

            Console.WriteLine("Threads in use = " + threads);
            Console.WriteLine("Total memory in use (in bytes) = " + mem_total * sizeof(long));
            Console.WriteLine("Table length = " + mem_total);
            Console.WriteLine("Total updates count to be done = " + updates_total);
            Console.WriteLine("Atomicity is " + (atomicity ? "on": "off"));
            Console.WriteLine("Verifying is " + (verify ? "on" : "off"));
            Console.WriteLine("Please wait...");

            long[] Table = new long[mem_total];
            for (int k = 0; k<= Table.Length; k++)
                Table[k] = k;

            var randomAccess = new RandomAccess(atomicity);

            TimeSpan old = DateTime.Now.TimeOfDay;
            RunTest(randomAccess, Table, memorySizePerThread, threads);
            TimeSpan time_res = DateTime.Now.TimeOfDay - old;
            
            double total_time = (time_res.Minutes * 60 + time_res.Seconds + time_res.Milliseconds * 0.001);
            Console.WriteLine("CPU time used  = " + total_time + " seconds");
            Console.WriteLine("GUPS = " + (updates_total / total_time / 1e9).ToString("N12"));

            if (verify)
            {
                Console.WriteLine("Verifying...");

                //for verification doing access in serial and so safe mode
        atomicity = false;

                randomAccess.Access(Table, 0, mem_total);
      
                long errcount = 0;
                for (long i = 0; i <= Table.Length; i++)
                    if(Table[i]!=i)
                        errcount++;

                Console.WriteLine("Found " + errcount + " errors in " + 
                Table.Length + " locations." + "(" + (float)errcount / 
                (float)Table.Length * 100.0f + "%).");
            }
            Console.WriteLine("Press any key...");
            Console.ReadKey();
        }

        static public void RunTest(RandomAccess randomAccess, long[] Table, ulong memorySizePerThread, uint threads)
        {
            Parallel.For(0, (int)threads, i =ge;
            {
                randomAccess.Access(Table, (uint)i, memorySizePerThread);
            });
        }
    }
}