大佬们分析一下，为什么这种方式调用函数会慢10倍？

考虑用T0是因为希望能写出对gc友好的代码

package main

import (
    "testing"
)

type Response struct {
    Name  string
    Age   int
    Hobby string
}

type Request struct {
    Name  string
    Age   int
    Hobby string
}

 //考虑不用这种的原因是因为变量逃逸了，感觉大量使用这种方式对gc不太好
func Resp1(r *Request) *Response { 
    return &Response{
        r.Name,
        r.Age,
        r.Name,
    }
}

//这种方式没有逃逸，但是为什么速度会变慢？按理说和上面的速度应该是相当的啊。
func Resp0(r *Request, res *Response) { 
    res.Age = r.Age
    res.Name = r.Name
    res.Hobby = r.Name
}

func T0() {
    resp := Response{}
    req := Request{Name: "111", Age: 10, Hobby: "code"}
    Resp0(&req, &resp)
    if resp.Age == 0 {
        return
    }
}

func T1() {
    req := Request{Name: "111", Age: 10, Hobby: "code"}
    resp := Resp1(&req)
    if resp.Age == 0 {
        return
    }
}

func BenchmarkT0AndT1(b *testing.B) {
     //BenchmarkT0AndT1/T0-16  519476035    2.229 ns/op     0 B/op     0 allocs/op
    b.Run("T0", func(b *testing.B) {
        for i := 0; i < b.N; i++ {
            T0()//大概慢了10倍，有点不可思议。
        }
    })

     //BenchmarkT0AndT1/T1-16  1000000000   0.2679 ns/op    0 B/op    0 allocs/op
    b.Run("T1", func(b *testing.B) {
        for i := 0; i < b.N; i++ {
            T1() //为什么这个会快得多？
        }
    })

    //结果
    //BenchmarkT0AndT1/T0-16  519476035                2.229 ns/op           0 B/op          0 allocs/op
    //BenchmarkT0AndT1/T1-16  1000000000               0.2679 ns/op          0 B/op          0 allocs/op
}