Added delete function benchmarks

Author: alexcams

pkg/ottl/ottlfuncs/func_delete.go

@@ -69,7 +69,7 @@ func deleteFrom[K any](target ottl.PSliceGetSetter[K], startIndexGetter ottl.Int
 		}
 
 		var i int64
-		t.RemoveIf(func(v pcommon.Value) bool {
+		t.RemoveIf(func(_ pcommon.Value) bool {
 			remove := i >= startIndex && i < endIndex
 			i++
 			return remove

pkg/ottl/ottlfuncs/func_delete_test.go

@@ -6,6 +6,7 @@ package ottlfuncs
 import (
 	"context"
 	"errors"
+	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -323,3 +324,106 @@ func TestDelete_Errors(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkDelete_Position_SliceSizes(b *testing.B) {
+	testCases := []struct {
+		name             string
+		sliceSize, index int
+	}{
+		{"Last-Small/10", 10, 9},
+		{"Last-Medium/100", 100, 99},
+		{"Last-Large/1000", 1000, 999},
+		{"Last-Huge/10000", 10000, 9999},
+		{"Middle-Small/10", 10, 4},
+		{"Middle-Medium/100", 100, 49},
+		{"Middle-Large/1000", 1000, 499},
+		{"Middle-Huge/10000", 10000, 4999},
+		{"First-Small/10", 10, 0},
+		{"First-Medium/100", 100, 0},
+		{"First-Large/1000", 1000, 0},
+		{"First-Huge/10000", 10000, 0},
+	}
+	for _, tc := range testCases {
+		b.Run(tc.name, func(b *testing.B) {
+			benchmarkDeleteIndex(b, tc.sliceSize, tc.index)
+		})
+	}
+}
+
+func BenchmarkDelete_DeleteRanges(b *testing.B) {
+	testCases := []struct {
+		name                  string
+		sliceSize, start, end int
+	}{
+		{"Range1", 1000, 500, 501},
+		{"Range10", 1000, 500, 510},
+		{"Range100", 1000, 500, 600},
+		{"Range500", 1000, 500, 999},
+	}
+	for _, tc := range testCases {
+		b.Run(tc.name, func(b *testing.B) {
+			benchmarkDelete(b, tc.sliceSize, tc.start, tc.end)
+		})
+	}
+}
+
+func benchmarkDeleteIndex(b *testing.B, sliceSize, index int) {
+	benchmarkDelete(b, sliceSize, index, 0)
+}
+
+func benchmarkDelete(b *testing.B, sliceSize, startIndex, endIndex int) {
+	startIndexGetter := mockIntGetter(int64(startIndex))
+
+	var endIndexGetter ottl.Optional[ottl.IntGetter[any]]
+	if endIndex > 0 {
+		endIndexGetter = ottl.NewTestingOptional(mockIntGetter(int64(endIndex)))
+	} else {
+		endIndexGetter = nilOptional
+	}
+
+	originalSlice := createBenchmarkSlice(sliceSize)
+
+	b.ResetTimer()
+	b.ReportAllocs()
+
+	for i := 0; i < b.N; i++ {
+		// Create a copy of the slice for each iteration, since we're modifying target inside deleteFrom func.
+		sourceSlice := pcommon.NewSlice()
+		originalSlice.CopyTo(sourceSlice)
+
+		target := sliceGetSetter(func(_ context.Context, _ any) (any, error) {
+			return sourceSlice, nil
+		})
+		exprFunc := deleteFrom(target, startIndexGetter, endIndexGetter)
+
+		res := pcommon.NewSlice()
+		b.StartTimer()
+		_, err := exprFunc(b.Context(), res)
+		b.StopTimer()
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func createBenchmarkSlice(sliceSize int) pcommon.Slice {
+	slice := pcommon.NewSlice()
+
+	for i := 0; i < sliceSize; i++ {
+		switch i % 5 {
+		case 0:
+			slice.AppendEmpty().SetStr(fmt.Sprintf("string_%d", i))
+		case 1:
+			slice.AppendEmpty().SetInt(int64(i))
+		case 2:
+			slice.AppendEmpty().SetDouble(float64(i))
+		case 3:
+			slice.AppendEmpty().SetBool(i%2 == 0)
+		case 4:
+			nested := slice.AppendEmpty().SetEmptySlice()
+			nested.AppendEmpty().SetInt(int64(i))
+		}
+	}
+
+	return slice
+}