Exemplo n.º 1
0
        public void DoubleWhere()
        {
            using (Benchmarker b = new Benchmarker($"ushort[{Count:n0}] | where [Value] < 50 || [Value] > 950 | count", DefaultMeasureMilliseconds))
            {
                b.Measure("For Count", Values.Length, () =>
                {
                    int count = 0;
                    for (int i = 0; i < Values.Length; ++i)
                    {
                        if (Values[i] < 50 || Values[i] > 950)
                        {
                            count++;
                        }
                    }
                    return(count);
                });

                b.Measure("XForm Count", Values.Length, () =>
                {
                    return((int)Context.FromArrays(Values.Length)
                           .WithColumn("Value", Values)
                           .Query("where [Value] < 50 || [Value] > 950", Context)
                           .Count());
                });

                b.AssertResultsEqual();
            }
        }
Exemplo n.º 2
0
        public void WhereUShortEqualsUshort()
        {
            using (Benchmarker b = new Benchmarker($"ushort[{Count:n0}] | where [Value] = [Threshold] | count", DefaultMeasureMilliseconds))
            {
                b.Measure("For Count", Values.Length, () =>
                {
                    int count = 0;
                    for (int i = 0; i < Values.Length; ++i)
                    {
                        if (Values[i] == Thresholds[i])
                        {
                            count++;
                        }
                    }
                    return(count);
                });

                b.Measure("XForm Count", Values.Length, () =>
                {
                    return((int)Context.FromArrays(Values.Length)
                           .WithColumn("Value", Values)
                           .WithColumn("Threshold", Thresholds)
                           .Query("where [Value] = [Threshold]", Context)
                           .Count());
                });

                b.AssertResultsEqual();
            }
        }
Exemplo n.º 3
0
        //public void Join()
        //{
        //    int joinFromLength = Math.Min(1000 * 1000, Values.Length);
        //    ushort[] joinTo = Enumerable.Range(10, 1000).Select((i) => (ushort)i).ToArray();

        //    using (Benchmarker b = new Benchmarker($"ushort[{joinFromLength:n0}] | join [Value] | count", DefaultMeasureMilliseconds))
        //    {
        //        b.Measure("XForm Join", joinFromLength, () =>
        //        {
        //            IXTable joinToSource = Context.FromArrays(joinTo.Length).WithColumn("ID", joinTo);

        //            IXTable enumerator = Context.FromArrays(joinFromLength).WithColumn("Value", Values);
        //            enumerator = new Join(enumerator, "Value", joinToSource, "ID", "");
        //            return (int)enumerator.Count();
        //        });
        //    }
        //}

        public void Dictionary()
        {
            int count = 4 * 1000 * 1000;
            Dictionary <int, int>  expected = new Dictionary <int, int>();
            Dictionary5 <int, int> actual   = new Dictionary5 <int, int>(new EqualityComparerAdapter <int>(TypeProviderFactory.Get(typeof(int)).TryGetComparer()));

            int[]  values = new int[count];
            Random r      = new Random(5);

            for (int i = 0; i < count; ++i)
            {
                values[i] = r.Next();
            }

            using (Benchmarker b = new Benchmarker($"Dictionary<int, int> [{count:n0}]", DefaultMeasureMilliseconds))
            {
                b.Measure("System.Collections.Generic.Dictionary", count, () =>
                {
                    int containsCount = 0;
                    for (int i = 0; i < count; ++i)
                    {
                        expected[values[i]] = i;
                        if (expected.ContainsKey(values[i]))
                        {
                            containsCount++;
                        }
                    }

                    return(expected.Count + containsCount);
                });

                b.Measure("XForm.Dictionary5", count, () =>
                {
                    int containsCount = 0;
                    for (int i = 0; i < count; ++i)
                    {
                        actual.Add(values[i], i);
                        if (actual.ContainsKey(values[i]))
                        {
                            containsCount++;
                        }
                    }

                    return(actual.Count + containsCount);
                });

                b.AssertResultsEqual();
            }
        }
        public void Current()
        {
            ColumnCache.IsEnabled = true;

            string query;

            // Still want to tune schema requests. Current bottleneck: LatestBeforeCutoff
            //query = @"
            //    read WebRequest
            //    schema
            //";

            //query = @"
            //    read Asset.Extended.Release.Typed
            //    where [Asset_SourceID] = 29 AND [IsBaseline] = 0";

            //query = @"
            //    read Identity.StandingAdmins.AssetAdminSummary.V0
            //    join [Name] Asset.Extended.Release [Name] Asset. ";

            //query = @"
            //    read WebRequestHuge
            //    peek [DataCenter]";

            //query = @"
            //    read WebRequestHuge.Typed
            //    where [EventTime] = null
            //    count";

            query = @"
                read WebRequest
                where [ClientBrowser]: ""Edge""
                choose Max [ResponseBytes] [ClientOS]
                limit 10
            ";

            string singleLineQuery = XqlScanner.QueryToSingleLineStyle(query);

            using (Benchmarker b = new Benchmarker(singleLineQuery, 10000))
            {
                b.Measure($"XForm", 1, () =>
                {
                    return(Context.Query(query).Count());
                });
            }
        }
Exemplo n.º 5
0
        public void Sample()
        {
            Random        r   = new Random(8);
            ArraySelector all = ArraySelector.All(10240);

            int[] eighthArray      = null;
            int[] sixtyfourthArray = null;

            using (Benchmarker b = new Benchmarker($"Sampler.Eighth", DefaultMeasureMilliseconds))
            {
                b.Measure("Sampler.Eighth", all.Count, () =>
                {
                    ArraySelector eighth      = Sampler.Eighth(all, r, ref eighthArray);
                    ArraySelector sixtyfourth = Sampler.Eighth(eighth, r, ref sixtyfourthArray);
                    return(sixtyfourth.Count);
                });
            }
        }
Exemplo n.º 6
0
        public void ByteEqualsConstant()
        {
            byte[] bytes = new byte[1000 * 1000];
            Random r     = new Random(8);

            r.NextBytes(bytes);

            using (Benchmarker b = new Benchmarker($"byte[{bytes.Length:n0}] | where [Value] < 16 | count", DefaultMeasureMilliseconds))
            {
                b.Measure("For Count", bytes.Length, () =>
                {
                    int count = 0;
                    for (int i = 0; i < bytes.Length; ++i)
                    {
                        if (bytes[i] < 16)
                        {
                            count++;
                        }
                    }
                    return(count);
                });

                b.Measure("Linq Count", bytes.Length, () =>
                {
                    return(bytes.Where((i) => i < 16).Count());
                });

                b.Measure("XForm Count", bytes.Length, () =>
                {
                    return((int)Context.FromArrays(bytes.Length)
                           .WithColumn("Value", bytes)
                           .Query("where [Value] < 16", Context)
                           .Count());
                });

                b.AssertResultsEqual();
            }
        }
Exemplo n.º 7
0
        public void Choose()
        {
            XDatabaseContext context = new XDatabaseContext();

            int[] rankPattern = new int[] { 2, 3, 1, 4, 6, 5, 7, 9, 8 };

            // Build three arrays
            int distinctCount = 100000;
            int countPerID    = 9;
            int length        = countPerID * distinctCount;

            int[] id    = new int[length];
            int[] rank  = new int[length];
            int[] value = new int[length];

            for (int i = 0; i < length; ++i)
            {
                id[i]    = i / countPerID;               // ID is the same for three rows at a time
                rank[i]  = rankPattern[i % countPerID];  // Rank is [2, 3, 1] repeating (so the middle is the biggest)
                value[i] = i;                            // Value is the index of the real row
            }

            using (Benchmarker b = new Benchmarker($"Choose [{length:n0}]", 3 * DefaultMeasureMilliseconds))
            {
                b.Measure("Choose", length, () =>
                {
                    IXTable actual = Context.FromArrays(length)
                                     .WithColumn("ID", id)
                                     .WithColumn("Rank", rank)
                                     .WithColumn("Value", value)
                                     .Query("choose Max [Rank] [ID]", context);

                    return(actual.Count());
                });
            }
        }
Exemplo n.º 8
0
        public void TsvSplit()
        {
            Stream tsvStream = new MemoryStream();
            //Stream tsvStream = new FileStream("Sample.tsv", FileMode.Create);
            int rowCount = 1000 * 1000;

            WriteSampleTsv(tsvStream, 5, 1000 * 1000);

            byte[]    content = new byte[64 * 1024];
            BitVector cells   = new BitVector(content.Length);
            BitVector rows    = new BitVector(content.Length);

            int[] rowEnds = new int[1024];

            byte[] allContent = new byte[tsvStream.Length];
            tsvStream.Seek(0, SeekOrigin.Begin);
            tsvStream.Read(allContent, 0, allContent.Length);
            BitVector allCells = new BitVector(allContent.Length);
            BitVector allRows  = new BitVector(allContent.Length);

            using (Benchmarker b = new Benchmarker($"Tsv Parse [{rowCount:n0}] | count", DefaultMeasureMilliseconds))
            {
                b.Measure("Read only", (int)tsvStream.Length, () =>
                {
                    tsvStream.Seek(0, SeekOrigin.Begin);
                    while (true)
                    {
                        int lengthRead = tsvStream.Read(content, 0, content.Length);
                        if (lengthRead == 0)
                        {
                            break;
                        }
                    }

                    return(rowCount);
                });

                b.Measure("ReadLine | Split", (int)tsvStream.Length, () =>
                {
                    tsvStream.Seek(0, SeekOrigin.Begin);
                    int count           = 0;
                    StreamReader reader = new StreamReader(tsvStream);
                    {
                        // Header row
                        reader.ReadLine();

                        while (!reader.EndOfStream)
                        {
                            string line      = reader.ReadLine();
                            string[] cellSet = line.Split('\t');
                            count++;
                        }
                    }
                    return(count);
                });

                b.Measure("Elfie TsvReader", (int)tsvStream.Length, () =>
                {
                    tsvStream.Seek(0, SeekOrigin.Begin);
                    int count             = 0;
                    ITabularReader reader = TabularFactory.BuildReader(tsvStream, "Unused.tsv");
                    {
                        while (reader.NextRow())
                        {
                            count++;
                        }
                    }
                    return(count);
                });


                Func <byte[], int, int, ulong[], ulong[], int> splitTsvN = NativeAccelerator.GetMethod <Func <byte[], int, int, ulong[], ulong[], int> >("XForm.Native.String8N", "SplitTsv");
                b.Measure("XForm Native Split", (int)tsvStream.Length, () =>
                {
                    tsvStream.Seek(0, SeekOrigin.Begin);

                    int count = -1;
                    while (true)
                    {
                        int lengthRead = tsvStream.Read(content, 0, content.Length);
                        if (lengthRead == 0)
                        {
                            break;
                        }
                        if (lengthRead < content.Length)
                        {
                            Array.Clear(content, lengthRead, content.Length - lengthRead);
                        }

                        int lineCount = splitTsvN(content, 0, lengthRead, cells.Array, rows.Array);
                        count        += lineCount;

                        int fromRow   = 0;
                        int countCopy = cells.Page(rowEnds, ref fromRow);
                    }

                    return(count);
                });

                b.MeasureParallel("XForm Native Split Parallel", (int)tsvStream.Length, (index, length) =>
                {
                    return(splitTsvN(allContent, index, length, allCells.Array, allRows.Array) - 1);
                });
            }
        }