JniMemberInfoLookup timing

Commit d1a9951 showed that *for just field lookup*, the idea of a
`ref struct JniMemberInfoLookup` *might* be a good idea.

Now that we've expanded `JniMemberInfoLookup` plumbing to include
*method* lookup, we can throw it into `TimingTests.cs` and see how it
compares!

The answer is that `ref struct`s and `Span<T>` are *not* magical
performance sauce with magical JIT support, and this is with CoreCLR!

	Method Lookup + Invoke Timing:
	           Traditional: 00:00:00.0175778
	            No caching: 00:00:00.0202369
	          Dict w/ lock: 00:00:00.0181357
	        ConcurrentDict: 00:00:00.0220411
	        JniPeerMembers: 00:00:00.0209174
	            JPM+Lookup: 00:00:00.0186421

	              (I)I virtual+traditional: 00:00:00.0000600
	           (I)I virtual+JniPeerMembers: 00:00:00.0000588
	               (I)I virtual+JPM+Lookup: 00:00:00.0007137

The new timings are `JPM+Lookup` and `virtual+JPM+Lookup`.

	// JniPeerMembers
	return _members.InstanceMethods.InvokeVirtualObjectMethod("toString.()Ljava/lang/String;", this, null);

	// JPM+Lookup
	var member = new JniMemberInfoLookup("toString.()Ljava/lang/String;", "toString"u8, "()Ljava/lang/String;"u8);
	ReadOnlySpan<JniArgumentValue> args = null;
	return _members.InstanceMethods.InvokeVirtualObjectMethod (member, this, args);

We see that JPM+Lookup is 11% *faster* when no arguments are involved.
Nice!

Throw an argument into the mix:

	// (I)I virtual+JniPeerMembers
	var args = stackalloc JniArgumentValue [1];
	args [0] = new JniArgumentValue (value);
	return _members.InstanceMethods.InvokeVirtualInt32Method ("VirtualIntMethod1Args.(I)I", this, args);

	// (I)I virtual+JPM+Lookup
	var member = new JniMemberInfoLookup (
			"VirtualIntMethod1Args.(I)I",
			"VirtualIntMethod1Args"u8,
			"(I)I"u8
	);
	var args = stackalloc JniArgumentValue [1];
	args [0] = new JniArgumentValue (value);
	return _members.InstanceMethods.InvokeVirtualInt32Method (member, this, new ReadOnlySpan<JniArgumentValue> (args, 1));

and we're now a *whole order of magnitude worse*, taking 12.1x longer.

Which quickly makes this idea as-is unworkable.

Maybe it's the ReadOnlySpan<T> usage, and if I went back to straight
`JniArgumentValue*` values it would be better?

Author: jonpryor

tests/Java.Interop-PerformanceTests/Java.Interop-PerformanceTests.targets

@@ -4,7 +4,7 @@
       BeforeTargets="BeforeBuild"
       Inputs="@(JavaPerformanceTestJar)"
       Outputs="$(OutputPath)performance-test.jar">
-    <MakeDir Directories="$(IntermediateOutputPath)pt-classes" />
+    <MakeDir Directories="$(IntermediateOutputPath)pt-classes;$(OutputPath)" />
     <Exec Command="&quot;$(JavaCPath)&quot; $(_JavacSourceOptions) -d &quot;$(IntermediateOutputPath)pt-classes&quot; @(JavaPerformanceTestJar->'%(Identity)', ' ')" />
     <Exec Command="&quot;$(JarPath)&quot; cf &quot;$(OutputPath)performance-test.jar&quot; -C &quot;$(IntermediateOutputPath)pt-classes&quot; ." />
   </Target>

tests/Java.Interop-PerformanceTests/Java.Interop/JavaTiming.cs

@@ -128,6 +128,19 @@ public virtual unsafe int Timing_VirtualIntMethod_Marshal1Args (int value)
 			return _members.InstanceMethods.InvokeVirtualInt32Method ("VirtualIntMethod1Args.(I)I", this, args);
 		}
 
+		public virtual unsafe int Timing_Lookup_VirtualIntMethod_Marshal1Args (int value)
+		{
+			var member = new JniMemberInfoLookup (
+					"VirtualIntMethod1Args.(I)I",
+					"VirtualIntMethod1Args"u8,
+					"(I)I"u8
+			);
+			var args = stackalloc JniArgumentValue [1];
+			args [0] = new JniArgumentValue (value);
+
+			return _members.InstanceMethods.InvokeVirtualInt32Method (member, this, new ReadOnlySpan<JniArgumentValue> (args, 1));
+		}
+
 		public virtual int Timing_VirtualIntMethod_GenericMarshal1Args (int value)
 		{
 			return _members.InstanceMethods.InvokeGenericVirtualInt32Method ("VirtualIntMethod1Args.(I)I", this, value);
@@ -277,6 +290,17 @@ public unsafe JniObjectReference Timing_ToString_JniPeerMembers ()
 			return _members.InstanceMethods.InvokeVirtualObjectMethod (id, this, null);
 		}
 
+		public JniObjectReference Timing_ToString_JniPeerMembers_Lookup ()
+		{
+			var member = new JniMemberInfoLookup (
+					toString_name + "." + toString_sig,
+					"toString"u8,
+					"()Ljava/lang/String;"u8
+			);
+			ReadOnlySpan<JniArgumentValue> args = null;
+			return _members.InstanceMethods.InvokeVirtualObjectMethod (member, this, args);
+		}
+
 		public static unsafe JniObjectReference CreateRunnable ()
 		{
 			return _members.StaticMethods.InvokeObjectMethod ("CreateRunnable.()Ljava/lang/Runnable;", null);

tests/Java.Interop-PerformanceTests/Java.Interop/TimingTests.cs

@@ -357,6 +357,12 @@ public void MethodLookupTiming ()
 				}
 				tp.Stop ();
 
+				var tl = Stopwatch.StartNew ();
+				for (int i = 0; i < count; ++i) {
+					var s = o.Timing_ToString_JniPeerMembers_Lookup ();
+					JniObjectReference.Dispose (ref s);
+				}
+				tl.Stop ();
 
 				var vtt = Stopwatch.StartNew ();
 				for (int i = 0; i < count; ++i) {
@@ -370,16 +376,24 @@ public void MethodLookupTiming ()
 				}
 				vti.Stop ();
 
+				var vtl = Stopwatch.StartNew ();
+				for (int i = 0; i < count; ++i) {
+					o.Timing_Lookup_VirtualIntMethod_Marshal1Args (i);
+				}
+				vtl.Stop ();
+
 
 				Console.WriteLine ("Method Lookup + Invoke Timing:");
 				Console.WriteLine ("\t   Traditional: {0}", tt.Elapsed);
 				Console.WriteLine ("\t    No caching: {0}", ta.Elapsed);
 				Console.WriteLine ("\t  Dict w/ lock: {0}", td.Elapsed);
 				Console.WriteLine ("\tConcurrentDict: {0}", tc.Elapsed);
 				Console.WriteLine ("\tJniPeerMembers: {0}", tp.Elapsed);
+				Console.WriteLine ("\t    JPM+Lookup: {0}", tl.Elapsed);
 				Console.WriteLine ();
 				Console.WriteLine ("\t      (I)I virtual+traditional: {0}", vtt.Elapsed);
 				Console.WriteLine ("\t   (I)I virtual+JniPeerMembers: {0}", vti.Elapsed);
+				Console.WriteLine ("\t       (I)I virtual+JPM+Lookup: {0}", vtl.Elapsed);
 			}
 			using (var o = new DerivedJavaTiming ()) {
 				var ntt = Stopwatch.StartNew ();