Compiler Explorer

Source code

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Xml.Linq;

namespace LINQtest
{
    public static class Settings
    {
        public const int VECTORSIZE = 12800000;//640000;
    }

class Element : IComparable<Element>
    {
        private int tag;
        private int order;
        private int data;

public Element(int t, int o, int d)
        {
            tag = t;
            order = o;
            data = d;
        }

public Element(int idx)
        {
            tag=idx % 8;
            order=idx % 12;
            data=idx;
        }

public int Tag { get => tag; set => tag = value; }
        public int Order { get => order; set => order = value; }
        public int Data { get => data; set => data = value; }

public int CompareTo(Element? b) => b == null
                ? 1
                : (b.order * Settings.VECTORSIZE + b.data) -
                   (order * Settings.VECTORSIZE + data);

public bool ZeroTag => tag == 0;
        public int Cal => Order * Settings.VECTORSIZE + Data;
    }

class Program
    {
        static void checkResults(IEnumerable<Element> resultVector)
        {
            int d = 0;
            int o = 0;
            foreach (var element in resultVector)
            {
                if (d > element.Data && o > element.Order)
                    throw new Exception("Ordering failed");
                d = element.Data;
                o = element.Order;
            }
        }

static void testClasic(IReadOnlyList<Element> testVector, bool order, int run)
        {
            Stopwatch sw = new();
            sw.Start();

var resultVector = new List<Element>(testVector.Count / 8);

foreach (var element in testVector)
            {
                if (element.ZeroTag)
                    resultVector.Add(element);
            }

if (order)
                resultVector.Sort();

if (resultVector.Count != Settings.VECTORSIZE / 8)
                throw new Exception("Number of result elements not correct!");

checkResults(resultVector);

sw.Stop();

Console.WriteLine(
                "Classic ({0}), run {1} -> Time: {2} sec To be: {3} Result: {4}",
                (order ? "ordered" : "not ordered"), run, sw.Elapsed.ToString().Substring(7),
                Settings.VECTORSIZE / 8, resultVector.Count());
        }

static void testLINQ(IReadOnlyList<Element> testVector, bool order, int run)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();

List<Element> resultVector = (order ?
                    testVector.Where(element => element.ZeroTag)
                              .OrderBy(element => element.Cal) :
                    testVector.Where(element => element.ZeroTag)).ToList();

if (resultVector.Count() != Settings.VECTORSIZE / 8)
                throw new Exception("Number of result elements not correct!");

checkResults(resultVector);

sw.Stop();

Console.WriteLine(
                "LINQ ({0}),    run {1} -> Time: {2} sec To be: {3} Result: {4}",
                (order ? "ordered" : "not ordered"), run, sw.Elapsed.ToString().Substring(7),
                Settings.VECTORSIZE / 8, resultVector.Count());
        }

static void Main(string[] args)
        {
            var testVector = new List<Element>(Settings.VECTORSIZE);
            for (int index = 0; index < Settings.VECTORSIZE; index++)
                testVector.Add(new(index));

for (int run = 0; run < 4; run++)
            {
                testLINQ(testVector, false, run);
                testClasic(testVector, false, run);
            }
            for (int run = 0; run < 4; run++)
            {
                testLINQ(testVector, true, run);
                testClasic(testVector, true, run);
            }

// var key = Console.ReadKey();
        }
    }
}