[PerformanceTests] Add timing for virtual vs. nonvirtual invocation.

This is why we want JniPeerMembers in Xamarin.Android: CACHEING!

	## MethodInvocationTiming Timing: 00:00:03.6698748
	Method Lookup + Invoke Timing:
	           Traditional: 00:00:00.0018948
	            No caching: 00:00:00.0255321
	          Dict w/ lock: 00:00:00.0018600
	        ConcurrentDict: 00:00:00.0032975
	        JniPeerMembers: 00:00:00.0022527

	              (I)I virtual+traditional: 00:00:00.0000809
	           (I)I virtual+JniPeerMembers: 00:00:00.0000873
	           (I)I nonvirtual+traditional: 00:00:00.0069499
	        (I)I nonvirtual+JniPeerMembers: 00:00:00.0001617

Xamarin.Android is close (-ish) to the `(I)I nonvirtual+traditional`
timing -- 0.0069s vs. 0.00008s for virtual dispatch (virtual dispatch
is ~86x faster! Though the bug [0] says ~4x on Android...?).

That's what we want to improve.

How's Java.Interop+JniPeerMembers do?

Virtual dispatch is 0.0000873s (slightly slower than
Xamarin.Android-style virtual dispatch [1]), but *nonvirtual* dispatch
is only 0.001617s, or 1.8x longer.

Still not entirely great -- we need to test this scenario on Android
-- but still nearly 2 orders of magnitude faster for nonvirtual
dispatch, which is a fairly common scenario.

[0]: https://bugzilla.xamarin.com/show_bug.cgi?id=32126
[1]: :-(

Author: jonpryor

tests/PerformanceTests/JavaTiming.cs

@@ -10,9 +10,13 @@ namespace Java.Interop.PerformanceTests
 	[JniTypeSignature (JniTypeName)]
 	public class JavaTiming : JavaObject
 	{
-		const               string          JniTypeName = "com/xamarin/interop/performance/JavaTiming";
+		protected   const   string          JniTypeName = "com/xamarin/interop/performance/JavaTiming";
 		static  readonly    JniPeerMembers  _members    = new JniPeerMembers (JniTypeName, typeof (JavaTiming));
 
+		public override JniPeerMembers JniPeerMembers {
+			get {return _members;}
+		}
+
 		static JniType _TypeRef;
 		internal static JniType TypeRef {
 			get {return JniType.GetCachedJniType (ref _TypeRef, JniTypeName);}
@@ -267,6 +271,16 @@ public JniObjectReference Timing_ToString_DictWithNoLock ()
 				(s, c) => c ?? TypeRef.GetInstanceMethod (toString_name, toString_sig));
 			return m.InvokeVirtualObjectMethod (PeerReference);
 		}
+
+		public unsafe JniObjectReference Timing_ToString_JniPeerMembers ()
+		{
+			const string id = toString_name + "\u0000" + toString_sig;
+			return _members.InstanceMethods.InvokeVirtualObjectMethod (id, this, null);
+		}
+	}
+
+	[JniTypeSignature (JniTypeName)]
+	class DerivedJavaTiming : JavaTiming {
 	}
 }
 

tests/PerformanceTests/TimingTests.cs

@@ -350,11 +350,51 @@ public void MethodLookupTiming ()
 				}
 				tc.Stop ();
 
+				var tp = Stopwatch.StartNew ();
+				for (int i = 0; i < count; ++i) {
+					var s = o.Timing_ToString_JniPeerMembers ();
+					JniEnvironment.References.Dispose (ref s);
+				}
+				tp.Stop ();
+
+
+				var vtt = Stopwatch.StartNew ();
+				for (int i = 0; i < count; ++i) {
+					o.VirtualIntMethod1Args (i);
+				}
+				vtt.Stop ();
+
+				var vti = Stopwatch.StartNew ();
+				for (int i = 0; i < count; ++i) {
+					o.Timing_VirtualIntMethod_Marshal1Args (i);
+				}
+				vti.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 ();
+				Console.WriteLine ("\t      (I)I virtual+traditional: {0}", vtt.Elapsed);
+				Console.WriteLine ("\t   (I)I virtual+JniPeerMembers: {0}", vti.Elapsed);
+			}
+			using (var o = new DerivedJavaTiming ()) {
+				var ntt = Stopwatch.StartNew ();
+				for (int i = 0; i < count; ++i) {
+					o.VirtualIntMethod1Args (i);
+				}
+				ntt.Stop ();
+
+				var nti = Stopwatch.StartNew ();
+				for (int i = 0; i < count; ++i) {
+					o.Timing_VirtualIntMethod_Marshal1Args (i);
+				}
+				nti.Stop ();
+				Console.WriteLine ("\t   (I)I nonvirtual+traditional: {0}", ntt.Elapsed);
+				Console.WriteLine ("\t(I)I nonvirtual+JniPeerMembers: {0}", nti.Elapsed);
 			}
 
 			total.Stop ();