Add LTTngCds Unit Test that only references LTTngCds (Microsoft.Performance.Toolkit.Plugins.LTTngPlugin) and tests some data with basic cooker including CurrentCpu - equivalent to cpu_id (#105)

Author: ivberg

LTTngCdsUnitTest/LTTngBaseSourceCooker.cs

@@ -0,0 +1,85 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+using System.Collections.Generic;
+using System.Threading;
+using LTTngCds.CookerData;
+using Microsoft.Performance.SDK;
+using Microsoft.Performance.SDK.Extensibility;
+using Microsoft.Performance.SDK.Extensibility.DataCooking;
+using Microsoft.Performance.SDK.Extensibility.DataCooking.SourceDataCooking;
+
+namespace LTTngCdsUnitTest.SourceDataCookers
+{
+    public abstract class LTTngBaseSourceCooker
+        : CookedDataReflector,
+          ISourceDataCooker<LTTngEvent, LTTngContext, string>
+    {
+        private static readonly HashSet<string> emptyDataKeys = new HashSet<string>();
+        protected static readonly ReadOnlyHashSet<string> EmptyDataKeys = new ReadOnlyHashSet<string>(emptyDataKeys);
+
+        protected LTTngBaseSourceCooker(string cookerId)
+            : this(DataCookerPath.ForSource(LTTngConstants.SourceId, cookerId))
+        {
+        }
+
+        protected LTTngBaseSourceCooker(DataCookerPath dataCookerPath)
+            : base(dataCookerPath)
+        {
+            this.Path = dataCookerPath;
+        }
+
+        protected long computeTime = 0;
+
+        /// <summary>
+        /// All source data cookers that inherit from this reference the LTTng source parser.
+        /// </summary>
+        public string SourceParserId => Path.SourceParserId;
+
+        /// <summary>
+        /// The data cooker identifier.
+        /// </summary>
+        public string DataCookerId => Path.DataCookerId;
+
+        /// <summary>
+        /// Combines the SourceId and the cooker Id.
+        /// </summary>
+        public virtual DataCookerPath Path { get; }
+
+        /// <summary>
+        /// No additional options by default.
+        /// </summary>
+        public virtual SourceDataCookerOptions Options => SourceDataCookerOptions.None;
+
+        /// <summary>
+        /// Default to no dependencies.
+        /// </summary>
+        public virtual IReadOnlyCollection<DataCookerPath> RequiredDataCookers => new HashSet<DataCookerPath>();
+
+        /// <summary>
+        /// Default consumption types - by default.
+        /// </summary>
+        public virtual IReadOnlyDictionary<DataCookerPath, DataCookerDependencyType> DependencyTypes =>
+            new Dictionary<DataCookerPath, DataCookerDependencyType>();
+
+        public abstract string Description { get; }
+
+        public virtual DataProductionStrategy DataProductionStrategy { get; }
+
+        public abstract ReadOnlyHashSet<string> DataKeys { get; }
+
+        public virtual void BeginDataCooking(ICookedDataRetrieval dependencyRetrieval, CancellationToken cancellationToken)
+        {
+
+        }
+
+        public virtual void EndDataCooking(CancellationToken cancellationToken)
+        {
+        }
+
+        public abstract DataProcessingResult CookDataElement(
+            LTTngEvent data, 
+            LTTngContext context,
+            CancellationToken cancellationToken);
+    }
+}

LTTngCdsUnitTest/LTTngCdsUnitTest.cs

@@ -0,0 +1,90 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using LTTngCdsUnitTest.SourceDataCookers;
+using Microsoft.Performance.SDK.Extensibility;
+using Microsoft.Performance.SDK.Processing;
+using Microsoft.Performance.Toolkit.Engine;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace LTTngCdsUnitTest
+{
+    [TestClass]
+    public class LTTngCdsUnitTest
+    {
+        public static bool IsTraceProcessed = false;
+        public static object IsTraceProcessedLock = new object();
+
+        private static RuntimeExecutionResults RuntimeExecutionResults;
+
+        private static DataCookerPath LTTngEventDataCookerPath;
+
+        public static void ProcessTrace()
+        {
+            lock (IsTraceProcessedLock)
+            {
+                if (!IsTraceProcessed)
+                {
+                    // Input data
+                    string[] lttngData = { @"..\..\..\..\TestData\LTTng\lttng-kernel-trace.ctf" };
+                    var lttngDataPath = new FileInfo(lttngData[0]);
+                    Assert.IsTrue(lttngDataPath.Exists);
+
+                    var runtime = Engine.Create(new FileDataSource(lttngDataPath.FullName));
+
+                    // Enable our various types of data
+                    var lttngDataCooker = new LTTngEventDataCooker();
+                    LTTngEventDataCookerPath = lttngDataCooker.Path;
+                    runtime.EnableCooker(LTTngEventDataCookerPath);
+
+                    //
+                    // Process our data.
+                    //
+
+                    RuntimeExecutionResults = runtime.Process();
+
+                    IsTraceProcessed = true;
+                }
+            }
+        }
+
+        [TestMethod]
+        public void TestLTTngEvent()
+        {
+            ProcessTrace();
+
+            var eventData = RuntimeExecutionResults.QueryOutput<IReadOnlyList<LTTngEventWithContext>>(
+                new DataOutputPath(
+                    LTTngEventDataCookerPath,
+                    nameof(LTTngEventDataCooker.Events)));
+
+            Assert.IsTrue(eventData.Count == 936356);
+
+            var lttngEvent3 = eventData[3];
+
+            // Context
+            Assert.IsTrue(lttngEvent3.LTTngContext.Clocks.Count == 1);
+            Assert.IsTrue(lttngEvent3.LTTngContext.Clocks["monotonic"].Name == "monotonic");
+            Assert.IsTrue(lttngEvent3.LTTngContext.Clocks["monotonic"].Frequency == 1000000000);
+            Assert.IsTrue(lttngEvent3.LTTngContext.Clocks["monotonic"].Offset == 1565905093154690150);
+            Assert.IsTrue(lttngEvent3.LTTngContext.CurrentCpu == 1);
+            Assert.IsTrue(lttngEvent3.LTTngContext.Timestamp == 7120199554940);
+            Assert.IsTrue(lttngEvent3.LTTngContext.TracerMajor == 9 &&
+                          lttngEvent3.LTTngContext.TracerMinor == 10);
+
+            // LTTngEvent
+            Assert.IsTrue(lttngEvent3.LTTngEvent.Id == 1178);
+            Assert.IsTrue(lttngEvent3.LTTngEvent.Name == "sched_waking");
+            Assert.IsTrue(lttngEvent3.LTTngEvent.Payload.Fields.Count == 4);
+            Assert.IsTrue(lttngEvent3.LTTngEvent.StreamDefinedEventContext.Fields.Count == 3);
+            Assert.IsTrue(lttngEvent3.LTTngEvent.StreamDefinedEventContext.FieldsByName.ContainsKey("_tid"));
+            Assert.IsTrue(lttngEvent3.LTTngEvent.StreamDefinedEventContext.FieldsByName.ContainsKey("_pid"));
+            Assert.IsTrue(lttngEvent3.LTTngEvent.StreamDefinedEventContext.FieldsByName.ContainsKey("_procname"));
+            Assert.IsTrue(lttngEvent3.LTTngEvent.WallClockTime == new DateTime(637015090133542450));
+            Assert.IsTrue(lttngEvent3.LTTngEvent.Timestamp == new Microsoft.Performance.SDK.Timestamp(7120199554940));
+        }
+    }
+}

LTTngCdsUnitTest/LTTngCdsUnitTest.csproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.1.0" />
+    <PackageReference Include="Microsoft.Performance.Toolkit.Engine" Version="1.0.16" />
+    <PackageReference Include="MSTest.TestAdapter" Version="2.2.8" />
+    <PackageReference Include="MSTest.TestFramework" Version="2.2.8" />
+    <PackageReference Include="coverlet.collector" Version="3.1.2" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\LTTngCds\LTTngCds.csproj" />
+  </ItemGroup>
+
+</Project>

LTTngCdsUnitTest/LTTngEventDataCooker.cs

@@ -0,0 +1,76 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+using System;
+using System.Threading;
+using System.Collections.Generic;
+using CtfPlayback;
+using LTTngCds.CookerData;
+using Microsoft.Performance.SDK;
+using Microsoft.Performance.SDK.Extensibility;
+using Microsoft.Performance.SDK.Extensibility.DataCooking;
+using Microsoft.Performance.SDK.Extensibility.DataCooking.SourceDataCooking;
+using Microsoft.Performance.SDK.Processing;
+
+namespace LTTngCdsUnitTest.SourceDataCookers
+{
+    public class LTTngEventDataCooker
+        : LTTngBaseSourceCooker
+    {
+        public const string Identifier = "LTTngEvents";
+
+        public override string Description => "All events reported in the source.";
+
+        public LTTngEventDataCooker()
+            : base(Identifier)
+        {
+            this.Events = new ProcessedEventData<LTTngEventWithContext>();
+        }
+
+        /// <summary>
+        /// No specific data keys for generic events, rather, the ReceiveAllEvents option is set.
+        /// </summary>
+        public override ReadOnlyHashSet<string> DataKeys => EmptyDataKeys;
+
+        /// <summary>
+        /// This data cooker receives all data elements.
+        /// </summary>
+        public override SourceDataCookerOptions Options => SourceDataCookerOptions.ReceiveAllDataElements;
+
+        public override DataProcessingResult CookDataElement(
+            LTTngEvent data, 
+            LTTngContext context, 
+            CancellationToken cancellationToken)
+        {
+            try
+            {
+                Events.AddEvent(new LTTngEventWithContext(data, context));
+
+                this.MaximumEventFieldCount =
+                    Math.Max(data.Payload.Fields.Count, this.MaximumEventFieldCount);
+            }
+            catch (CtfPlaybackException e)
+            {
+                Console.Error.WriteLine($"Error consuming event: {e.Message}");
+                return DataProcessingResult.CorruptData;
+            }
+
+            return DataProcessingResult.Processed;
+        }
+
+        public override void EndDataCooking(CancellationToken cancellationToken)
+        {
+            this.Events.FinalizeData();
+        }
+
+        [DataOutput]
+        public ProcessedEventData<LTTngEventWithContext> Events { get; }
+
+
+        /// <summary>
+        /// The highest number of fields found in any single event.
+        /// </summary>
+        [DataOutput]
+        public int MaximumEventFieldCount { get; private set; }
+    }
+}

LTTngCdsUnitTest/LTTngEventWithContext.cs

@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+using LTTngCds.CookerData;
+
+namespace LTTngCdsUnitTest
+{
+    public class LTTngEventWithContext
+    {
+        public LTTngEventWithContext(LTTngEvent lTTngEvent, LTTngContext lTTngContext)
+        {
+            LTTngEvent = lTTngEvent;
+            LTTngContext = lTTngContext;
+        }
+
+        public LTTngEvent LTTngEvent { get; private set; }
+        public LTTngContext LTTngContext { get; private set; }
+    }
+}