service/vendor/github.com/bytedance/sonic/option/option.go

86 lines
2.8 KiB
Go
Raw Normal View History

2023-12-21 22:17:40 +08:00
/*
* Copyright 2021 ByteDance Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package option
var (
// DefaultDecoderBufferSize is the initial buffer size of StreamDecoder
DefaultDecoderBufferSize uint = 128 * 1024
// DefaultEncoderBufferSize is the initial buffer size of Encoder
DefaultEncoderBufferSize uint = 128 * 1024
)
// CompileOptions includes all options for encoder or decoder compiler.
type CompileOptions struct {
// the maximum depth for compilation inline
MaxInlineDepth int
// the loop times for recursively pretouch
RecursiveDepth int
}
var (
// Default value(3) means the compiler only inline 3 layers of nested struct.
// when the depth exceeds, the compiler will recurse
// and compile subsequent structs when they are decoded
DefaultMaxInlineDepth = 3
// Default value(1) means `Pretouch()` will be recursively executed once,
// if any nested struct is left (depth exceeds MaxInlineDepth)
DefaultRecursiveDepth = 1
)
// DefaultCompileOptions set default compile options.
func DefaultCompileOptions() CompileOptions {
return CompileOptions{
RecursiveDepth: DefaultRecursiveDepth,
MaxInlineDepth: DefaultMaxInlineDepth,
}
}
// CompileOption is a function used to change DefaultCompileOptions.
type CompileOption func(o *CompileOptions)
// WithCompileRecursiveDepth sets the loop times of recursive pretouch
// in both decoder and encoder,
// for both concrete type and its pointer type.
//
// For deep nested struct (depth exceeds MaxInlineDepth),
// try to set more loops to completely compile,
// thus reduce JIT unstability in the first hit.
func WithCompileRecursiveDepth(loop int) CompileOption {
return func(o *CompileOptions) {
if loop < 0 {
panic("loop must be >= 0")
}
o.RecursiveDepth = loop
}
}
// WithCompileMaxInlineDepth sets the max depth of inline compile
// in decoder and encoder.
//
// For large nested struct, try to set smaller depth to reduce compiling time.
func WithCompileMaxInlineDepth(depth int) CompileOption {
return func(o *CompileOptions) {
if depth <= 0 {
panic("depth must be > 0")
}
o.MaxInlineDepth = depth
}
}