supply FastInvoker interface for reduce the function call memory consumption

tupunco · tupunco · commit 07e997cf1c18 · 2016-06-04T08:01:04.000+08:00
diff --git a/inject.go b/inject.go
@@ -50,6 +50,20 @@ type Invoker interface {
 	Invoke(interface{}) ([]reflect.Value, error)
 }
 
+// FastInvoker represents an interface for fast calling functions external function.
+type FastInvoker interface {
+	// Invoke
+	Invoke([]interface{}) ([]reflect.Value, error)
+}
+
+// IsFastInvoker check interface is FastInvoker
+func IsFastInvoker(h interface{}) bool {
+	if _, ok := h.(FastInvoker); ok {
+		return true
+	}
+	return false
+}
+
 // TypeMapper represents an interface for mapping interface{} values based on type.
 type TypeMapper interface {
 	// Maps the interface{} value based on its immediate type from reflect.TypeOf.
@@ -102,18 +116,52 @@ func New() Injector {
 // It panics if f is not a function
 func (inj *injector) Invoke(f interface{}) ([]reflect.Value, error) {
 	t := reflect.TypeOf(f)
+	numIn := t.NumIn()
+	switch v := f.(type) {
+	case FastInvoker:
+		return inj.fastInvoke(v, t, numIn)
+	default:
+		return inj.callInvoke(f, t, numIn)
+	}
+}
 
-	var in = make([]reflect.Value, t.NumIn()) //Panic if t is not kind of Func
-	for i := 0; i < t.NumIn(); i++ {
-		argType := t.In(i)
-		val := inj.GetVal(argType)
-		if !val.IsValid() {
-			return nil, fmt.Errorf("Value not found for type %v", argType)
-		}
+// fastInvoke fastInvoke call
+func (inj *injector) fastInvoke(f FastInvoker, t reflect.Type, numIn int) ([]reflect.Value, error) {
+	var in []interface{}
+	if numIn > 0 {
+		in = make([]interface{}, numIn) //Panic if t is not kind of Func
+		var argType reflect.Type
+		var val reflect.Value
+		for i := 0; i < numIn; i++ {
+			argType = t.In(i)
+			val = inj.GetVal(argType)
+			if !val.IsValid() {
+				return nil, fmt.Errorf("Value not found for type %v", argType)
+			}
 
-		in[i] = val
+			in[i] = val.Interface()
+		}
 	}
+	return f.Invoke(in)
+}
 
+// callInvoke reflect.Value.Call
+func (inj *injector) callInvoke(f interface{}, t reflect.Type, numIn int) ([]reflect.Value, error) {
+	var in []reflect.Value
+	if numIn > 0 {
+		in = make([]reflect.Value, numIn) //Panic if t is not kind of Func
+		var argType reflect.Type
+		var val reflect.Value
+		for i := 0; i < numIn; i++ {
+			argType = t.In(i)
+			val = inj.GetVal(argType)
+			if !val.IsValid() {
+				return nil, fmt.Errorf("Value not found for type %v", argType)
+			}
+
+			in[i] = val
+		}
+	}
 	return reflect.ValueOf(f).Call(in), nil
 }
 
diff --git a/inject_test.go b/inject_test.go
@@ -181,3 +181,88 @@ func Test_Injector_Implementors(t *testing.T) {
 		So(injector.GetVal(inject.InterfaceOf((*fmt.Stringer)(nil))).IsValid(), ShouldBeTrue)
 	})
 }
+
+//----------Benchmark Injecto rInvoke-------------
+
+func f1InjectorInvoke(d1 string, d2 SpecialString) string {
+	return "f1"
+}
+func f2InjectorInvoke(d1 string, d2 SpecialString) string {
+	return "f2"
+}
+
+func f1SimpleInjectorInvoke() {
+}
+func f2SimpleInjectorInvoke() {
+}
+
+// f2InjectorInvokeHandler f2 Invoke Handler
+type f2InjectorInvokeHandler func(d1 string, d2 SpecialString) string
+
+func (f2 f2InjectorInvokeHandler) Invoke(p []interface{}) ([]reflect.Value, error) {
+	ret := f2(p[0].(string), p[1].(SpecialString))
+	return []reflect.Value{reflect.ValueOf(ret)}, nil
+}
+
+type f2SimpleInjectorInvokeHandler func()
+
+func (f2 f2SimpleInjectorInvokeHandler) Invoke(p []interface{}) ([]reflect.Value, error) {
+	f2()
+	return nil, nil
+}
+
+func BenchmarkInjectorInvokeNative(b *testing.B) {
+	b.StopTimer()
+	dep := "some dependency"
+	dep2 := "another dep"
+	var d2 SpecialString
+	d2 = dep2
+
+	b.StartTimer()
+	for i := 0; i < b.N; i++ {
+		f1InjectorInvoke(dep, d2)
+	}
+}
+
+func BenchmarkInjectorInvokeOriginal(b *testing.B) {
+	benchmarkInjectorInvoke(b, false, false)
+}
+func BenchmarkInjectorInvokeFast(b *testing.B) {
+	benchmarkInjectorInvoke(b, true, false)
+}
+func BenchmarkInjectorInvokeOriginalSimple(b *testing.B) {
+	benchmarkInjectorInvoke(b, false, true)
+}
+func BenchmarkInjectorInvokeFastSimple(b *testing.B) {
+	benchmarkInjectorInvoke(b, true, true)
+}
+func benchmarkInjectorInvoke(b *testing.B, isFast, isSimple bool) {
+	b.StopTimer()
+
+	injector := inject.New()
+	dep := "some dependency"
+	injector.Map(dep)
+	dep2 := "another dep"
+	injector.MapTo(dep2, (*SpecialString)(nil))
+
+	var f1 interface{}
+	var f2 interface{}
+	if isSimple { //func()
+		f1 = f1SimpleInjectorInvoke
+		f2 = f2SimpleInjectorInvokeHandler(f2SimpleInjectorInvoke)
+	} else { //func(p1, p2) ret
+		f1 = f1InjectorInvoke
+		f2 = f2InjectorInvokeHandler(f2InjectorInvoke)
+	}
+	injector.Invoke(f1)
+	injector.Invoke(f2)
+
+	b.StartTimer()
+	for i := 0; i < b.N; i++ {
+		if isFast {
+			injector.Invoke(f2)
+		} else {
+			injector.Invoke(f1)
+		}
+	}
+}
