[*.{cs,vb}]

dotnet_sort_system_directives_first = true

dotnet_separate_import_directive_groups = true

[*.cs]

csharp_new_line_before_open_brace = true

csharp_new_line_before_else = true

csharp_new_line_before_catch = true

csharp_new_line_before_finally = true

using System;

using System.Collections.Generic;

using System.Linq;

using System.Reflection;

using Python.Runtime;

namespace Python.PerformanceTests

public class BaselineComparisonBenchmarkBase

{

public BaselineComparisonBenchmarkBase()

{

Console.WriteLine($"CWD: {Environment.CurrentDirectory}");

Console.WriteLine($"Using Python.Runtime from {typeof(PythonEngine).Assembly.Location} {typeof(PythonEngine).Assembly.GetName()}");

try {

PythonEngine.Initialize();

Console.WriteLine("Python Initialized");

if (PythonEngine.BeginAllowThreads() == IntPtr.Zero)

throw new PythonException();

Console.WriteLine("Threading enabled");

}

catch (Exception e) {

Console.WriteLine(e);

throw;

}

}

static BaselineComparisonBenchmarkBase()

{

string pythonRuntimeDll = Environment.GetEnvironmentVariable(BaselineComparisonConfig.EnvironmentVariableName);

if (string.IsNullOrEmpty(pythonRuntimeDll))

{

throw new ArgumentException(

"Required environment variable is missing",

BaselineComparisonConfig.EnvironmentVariableName);

}

Console.WriteLine("Preloading " + pythonRuntimeDll);

Assembly.LoadFrom(pythonRuntimeDll);

foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies()) {

if (assembly.FullName.StartsWith("Python.Runtime"))

Console.WriteLine(assembly.Location);

foreach(var dependency in assembly.GetReferencedAssemblies())

if (dependency.FullName.Contains("Python.Runtime")) {

Console.WriteLine($"{assembly} -> {dependency}");

}

}

AppDomain.CurrentDomain.AssemblyResolve += CurrentDomainOnAssemblyResolve;

}

static Assembly CurrentDomainOnAssemblyResolve(object sender, ResolveEventArgs args) {

if (!args.Name.StartsWith("Python.Runtime"))

return null;

var preloaded = AppDomain.CurrentDomain.GetAssemblies()

.FirstOrDefault(a => a.GetName().Name == "Python.Runtime");

if (preloaded != null) return preloaded;

string pythonRuntimeDll = Environment.GetEnvironmentVariable(BaselineComparisonConfig.EnvironmentVariableName);

if (string.IsNullOrEmpty(pythonRuntimeDll))

return null;

return Assembly.LoadFrom(pythonRuntimeDll);

}

}

using System;

using System.Collections.Generic;

using System.IO;

using System.Reflection;

using BenchmarkDotNet.Configs;

using BenchmarkDotNet.Jobs;

namespace Python.PerformanceTests

public class BaselineComparisonConfig : ManualConfig

{

public const string EnvironmentVariableName = "PythonRuntimeDLL";

public BaselineComparisonConfig()

{

this.Options |= ConfigOptions.DisableOptimizationsValidator;

string deploymentRoot = BenchmarkTests.DeploymentRoot;

var baseJob = Job.Default;

this.Add(baseJob

.WithId("baseline")

.WithEnvironmentVariable(EnvironmentVariableName,

Path.Combine(deploymentRoot, "baseline", "Python.Runtime.dll"))

.WithBaseline(true));

this.Add(baseJob

.WithId("new")

.WithEnvironmentVariable(EnvironmentVariableName,

Path.Combine(deploymentRoot, "new", "Python.Runtime.dll")));

}

static BaselineComparisonConfig() {

AppDomain.CurrentDomain.AssemblyResolve += CurrentDomainOnAssemblyResolve;

}

static Assembly CurrentDomainOnAssemblyResolve(object sender, ResolveEventArgs args) {

Console.WriteLine(args.Name);

if (!args.Name.StartsWith("Python.Runtime"))

return null;

string pythonRuntimeDll = Environment.GetEnvironmentVariable(EnvironmentVariableName);

if (string.IsNullOrEmpty(pythonRuntimeDll))

pythonRuntimeDll = Path.Combine(BenchmarkTests.DeploymentRoot, "baseline", "Python.Runtime.dll");

return Assembly.LoadFrom(pythonRuntimeDll);

}

}

using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Runtime.CompilerServices;

using System.Reflection;

using BenchmarkDotNet.Reports;

using BenchmarkDotNet.Running;

using NUnit.Framework;

namespace Python.PerformanceTests

public class BenchmarkTests

{

Summary summary;

[OneTimeSetUp]

public void SetUp()

{

Environment.CurrentDirectory = Path.Combine(DeploymentRoot, "new");

this.summary = BenchmarkRunner.Run<PythonCallingNetBenchmark>();

Assert.IsNotEmpty(this.summary.Reports);

Assert.IsTrue(this.summary.Reports.All(r => r.Success));

}

[Test]

public void ReadInt64Property()

{

double optimisticPerfRatio = GetOptimisticPerfRatio(this.summary.Reports);

Assert.LessOrEqual(optimisticPerfRatio, 0.68);

}

[Test]

public void WriteInt64Property()

{

double optimisticPerfRatio = GetOptimisticPerfRatio(this.summary.Reports);

Assert.LessOrEqual(optimisticPerfRatio, 0.66);

}

static double GetOptimisticPerfRatio(

IReadOnlyList<BenchmarkReport> reports,

[CallerMemberName] string methodName = null)

{

reports = reports.Where(r => r.BenchmarkCase.Descriptor.WorkloadMethod.Name == methodName).ToArray();

if (reports.Count == 0)

throw new ArgumentException(

message: $"No reports found for {methodName}. "

+ "You have to match test method name to benchmark method name or "

+ "pass benchmark method name explicitly",

paramName: nameof(methodName));

var baseline = reports.Single(r => r.BenchmarkCase.Job.ResolvedId == "baseline").ResultStatistics;

var @new = reports.Single(r => r.BenchmarkCase.Job.ResolvedId != "baseline").ResultStatistics;

double newTimeOptimistic = @new.Mean - (@new.StandardDeviation + baseline.StandardDeviation) * 0.5;

return newTimeOptimistic / baseline.Mean;

}

public static string DeploymentRoot => Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

}

<Project Sdk="Microsoft.NET.Sdk">

<PropertyGroup>

<TargetFramework>net461</TargetFramework>

<Configurations>DebugMono;DebugMonoPY3;ReleaseMono;ReleaseMonoPY3;DebugWin;DebugWinPY3;ReleaseWin;ReleaseWinPY3</Configurations>

<IsPackable>false</IsPackable>

</PropertyGroup>

<ItemGroup>

<PackageReference Include="BenchmarkDotNet" Version="0.11.5" />

<PackageReference Include="nunit" Version="3.12.0" />

<PackageReference Include="NUnit3TestAdapter" Version="3.13.0" />

<PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />

<PackageReference Include="pythonnet" Version="2.3.0" GeneratePathProperty="true">

<IncludeAssets>compile</IncludeAssets>

</PackageReference>

</ItemGroup>

<Target Name="GetRuntimeLibBuildOutput" BeforeTargets="Build">

<MSBuild Projects="..\runtime\Python.Runtime.15.csproj" Properties="PYTHONNET_PY3_VERSION=PYTHON35;Configuration=$(Configuration);TargetFramework=net40;Python3Version=PYTHON35;OutputPath=bin\for_perf\">

<Output TaskParameter="TargetOutputs" ItemName="NewPythonRuntime" />

</MSBuild>

</Target>

<Target Name="CopyBaseline" AfterTargets="Build">

<Copy SourceFiles="$(Pkgpythonnet)\lib\net40\Python.Runtime.dll" DestinationFolder="$(OutDir)\baseline" />

</Target>

<Target Name="CopyNewBuild" AfterTargets="Build">

<Copy SourceFiles="@(NewPythonRuntime)" DestinationFolder="$(OutDir)\new" />

</Target>

</Project>

using System;

using System.Collections.Generic;

using System.Text;

using BenchmarkDotNet.Attributes;

using Python.Runtime;

namespace Python.PerformanceTests

[Config(typeof(BaselineComparisonConfig))]

public class PythonCallingNetBenchmark: BaselineComparisonBenchmarkBase

{

[Benchmark]

public void ReadInt64Property()

{

using (Py.GIL())

{

var locals = new PyDict();

locals.SetItem("a", new NetObject().ToPython());

PythonEngine.Exec($@"

", locals: locals.Handle);

}

}

[Benchmark]

public void WriteInt64Property() {

using (Py.GIL()) {

var locals = new PyDict();

locals.SetItem("a", new NetObject().ToPython());

PythonEngine.Exec($@"

", locals: locals.Handle);

}

}

}

class NetObject

{

public long LongProperty { get; set; } = 42;

}