英文:
Can I optimize this Go reflect function so it isn't as slow?
问题
我正在进行一个项目，需要为所有支持的方法构建部分更新。每个部分更新都需要一个不同的结构体，具有不同的字段和字段数量，并且不知道哪些字段会存在或不存在。我决定遍历每个结构体字段，如果存在则将其添加到一个数组中，在最后返回该数组。我还花了一些时间对几个看起来最符合实际的函数进行了基准测试，以帮助做出决策。
所有结构体字段都将是指针。在这个前提下，这是我编写的函数。
注意：我无法为此创建一个playground示例，因为它不支持基准测试。我将链接完整的类，并将解释放在它们上面。
1）为每个部分更新结构体创建一个映射函数，我将单独检查每个字段。如果字段不为nil，我将以[key,value]的格式将值放入一个二维数组中。在处理完结构体后，返回该数组。
2）创建一个使用泛型和反射的单个映射函数，执行与上述相同的操作。
这是我运行的基准测试方法：
// main_test.gopackage mainimport ("testing""time")func BenchmarkBoth(b *testing.B) {field1 := "testfield1"field2 := "testfield2"field3 := "testfield3"field4 := "testfield4"field5 := "testfield5"date1, _ := time.Parse(time.RFC3339, "2004-10-16T12:40:53.00Z")str := &updateRequest{FieldOne: &field1,FieldTwo: &field2,FieldThree: &field3,FieldFour: &field4,FieldFive: &field5,FieldSix: &date1,}b.Run("ManualUpdateRequestMapping", func(b *testing.B) {for i := 0; i < b.N; i++ {_ = ManualUpdateRequestMapping(str)}})b.Run("ReflectUpdateRequestMapping", func(b *testing.B) {for i := 0; i < b.N; i++ {_ = ReflectUpdateRequestMapping(str)}})}
下面是测试结果和使用的CPU：
cpu: 12th Gen Intel(R) Core(TM) i9-12900KFBenchmarkBoth/ManualUpdateRequestMapping-24 3560083 331.9 ns/op 368 B/op 8 allocs/opBenchmarkBoth/ReflectUpdateRequestMapping-24 1393377 866.7 ns/op 648 B/op 21 allocs/opPASSok com.example.stack 3.745s
我预计反射函数会慢一些，但不会慢到大约2.5倍。它似乎还分配了大约2.5倍的资源。我在上面的代码中搞砸了吗，还是反射真的慢那么多？
如果有任何建议可以使上面的代码更高效，我愿意接受所有建议。我已经使用Go语言工作了大约3个月，所以如果我在上面的代码中犯了任何错误，请轻一点。:)
英文:
I am working on a project where I need to build out the partial updates for all of the methods that will be supported. Each partial update will require a different struct, with different fields and number of fields, and not knowing which ones will be present or not. I decided on going over each struct field, and if it's present adding it to an array to return at the end. I also took some time to Benchmark a couple of functions that seemed most realistic to approach this problem, and to help make a decision.
All of the structs fields will be pointers. With that in mind, these are the functions I wrote.
Note: I can't create a playground example for this, because it doesn't support Benchmarks. I'll link the full classes, and put the explanation above them.
- Create a mapping function for each partial update struct, where I would check each field separately. If the field is not
nil, I will put the value in a 2D array storing in a [key,value] format. After the struct has been processed, return the array. - Create a single mapping function that uses Generics and Reflection to do the same as above.
// main.gopackage mainimport ("reflect""strings""time")type updateRequest struct {FieldOne *string `json:"field_one,omitempty"`FieldTwo *string `json:"field_two,omitempty"`FieldThree *string `json:"field_three,omitempty"`FieldFour *string `json:"field_four,omitempty"`FieldFive *string `json:"field_five,omitempty"`FieldSix *time.Time `json:"field_six,omitempty" time_format:"2006-01-02"`}// Mapping function that would need to be recreated for each partial update struct.func ManualUpdateRequestMapping(req *updateRequest) [][]string {vals := make([][]string, 0, 6)if req.FieldOne != nil {vals = append(vals, []string{"field_one", *req.FieldOne})}if req.FieldTwo != nil && req.FieldThree != nil {vals = append(vals, []string{"field_two", *req.FieldTwo}, []string{"field_three", *req.FieldThree})}if req.FieldFour != nil {vals = append(vals, []string{"field_four", *req.FieldFour})}if req.FieldFive != nil {vals = append(vals, []string{"field_five", *req.FieldFive})}if req.FieldSix != nil {vals = append(vals, []string{"field_six", req.FieldSix.Format(time.RFC3339)})}return vals}// Generics and Reflection functionfunc ReflectUpdateRequestMapping[T *updateRequest](str T) [][]string {valHolder := reflect.ValueOf(*str)if valHolder.Kind() != reflect.Struct {return nil}vals := make([][]string, 0, valHolder.NumField())for i := 0; i < valHolder.NumField(); i++ {if valHolder.Field(i).IsNil() {continue}spl := strings.Split(valHolder.Type().Field(i).Tag.Get("json"), ",")if valHolder.Field(i).Elem().Type() != reflect.TypeOf(time.Time{}) {vals = append(vals, []string{spl[0], valHolder.Field(i).Elem().String()})} else {vals = append(vals, []string{spl[0], valHolder.Field(i).Interface().(*time.Time).Format(time.RFC3339)})}}return vals}
This is the benchmark method I ran with:
// main_test.gopackage mainimport ("testing""time")func BenchmarkBoth(b *testing.B) {field1 := "testfield1"field2 := "testfield2"field3 := "testfield3"field4 := "testfield4"field5 := "testfield5"date1, _ := time.Parse(time.RFC3339, "2004-10-16T12:40:53.00Z")str := &updateRequest{FieldOne: &field1,FieldTwo: &field2,FieldThree: &field3,FieldFour: &field4,FieldFive: &field5,FieldSix: &date1,}b.Run("ManualUpdateRequestMapping", func(b *testing.B) {for i := 0; i < b.N; i++ {_ = ManualUpdateRequestMapping(str)}})b.Run("ReflectUpdateRequestMapping", func(b *testing.B) {for i := 0; i < b.N; i++ {_ = ReflectUpdateRequestMapping(str)}})}
Below is the CPU used and the results that come from the test:
cpu: 12th Gen Intel(R) Core(TM) i9-12900KFBenchmarkBoth/ManualUpdateRequestMapping-24 3560083 331.9 ns/op 368 B/op 8 allocs/opBenchmarkBoth/ReflectUpdateRequestMapping-24 1393377 866.7 ns/op 648 B/op 21 allocs/opPASSok com.example.stack 3.745s
I expected the Reflection function to be slower, but not ~2.5x slower. It also seems to allocate ~2.5x more resources per iteration. Did I botch something in the code above, or is Reflection just that much slower?
If there are any recommendations to make the code above more efficient, I am open to all suggestions. I've been working with Go for about 3 months now, so please go easy on me if I committed any Golang treason in the code above. 
答案1
得分: 1
反射比非反射代码慢。这里有一个改进方法。一些注意事项：
- 通过将字段作为常规类型值获取并从那里进行操作，减少反射调用。
- 不需要那种新潮的类型参数东西。
- 说到Golang的背叛，语言的名称是Go。
解决了这些问题，下面是代码：
func UpdateRequestMapping(p any) [][]string {v := reflect.ValueOf(p).Elem()if v.Kind() != reflect.Struct {return nil}t := v.Type()result := make([][]string, t.NumField())for i := 0; i < t.NumField(); i++ {var ok boolvar value stringswitch f := v.Field(i).Interface().(type) {case *string:if f != nil {ok = truevalue = *f}case *time.Time:if f != nil {ok = truevalue = (*f).Format(time.RFC3339)}}if ok {name, _, _ := strings.Cut(t.Field(i).Tag.Get("json"), ",")result[i] = []string{name, value}}}return result}
英文:
Reflection is slower than non-reflection code. Here's an improvement. Some notes:
- Reduce reflect calls by getting the field as a regular typed value and working from there.
- There's no need for that new-fangled type parameter stuff.
- Speaking of Golang treason, the name of the language is Go.
With that out of the way, here's the code:
func UpdateRequestMapping(p any) [][]string {v := reflect.ValueOf(p).Elem()if v.Kind() != reflect.Struct {return nil}t := v.Type()result := make([][]string, t.NumField())for i := 0; i < t.NumField(); i++ {var ok boolvar value stringswitch f := v.Field(i).Interface().(type) {case *string:if f != nil {ok = truevalue = *f}case *time.Time:if f != nil {ok = truevalue = (*f).Format(time.RFC3339)}}if ok {name, _, _ := strings.Cut(t.Field(i).Tag.Get("json"), ",")result[i] = []string{name, value}}}return result}
通过集体智慧和协作来改善编程学习和解决问题的方式。致力于成为全球开发者共同参与的知识库，让每个人都能够通过互相帮助和分享经验来进步。
评论