adaptive_concurrencyv2alpha

package
v1.36.11-2025121120105... Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: unknown License: Apache-2.0 Imports: 10 Imported by: 0

Documentation

Index

Constants

View Source 
const AdaptiveConcurrency_ConcurrencyControllerConfig_not_set_case case_AdaptiveConcurrency_ConcurrencyControllerConfig = 0
View Source 
const AdaptiveConcurrency_GradientControllerConfig_case case_AdaptiveConcurrency_ConcurrencyControllerConfig = 1

Variables

View Source 
var File_envoy_config_filter_http_adaptive_concurrency_v2alpha_adaptive_concurrency_proto protoreflect.FileDescriptor

Functions

This section is empty.

Types

type AdaptiveConcurrency 

type AdaptiveConcurrency struct {

	// Types that are valid to be assigned to ConcurrencyControllerConfig:
	//
	//	*AdaptiveConcurrency_GradientControllerConfig
	ConcurrencyControllerConfig isAdaptiveConcurrency_ConcurrencyControllerConfig `protobuf_oneof:"concurrency_controller_config"`
	// If set to false, the adaptive concurrency filter will operate as a pass-through filter. If the
	// message is unspecified, the filter will be enabled.
	Enabled *core.RuntimeFeatureFlag `protobuf:"bytes,2,opt,name=enabled,proto3" json:"enabled,omitempty"`
	// contains filtered or unexported fields
}

func (*AdaptiveConcurrency) ClearConcurrencyControllerConfig 

func (x *AdaptiveConcurrency) ClearConcurrencyControllerConfig()

func (*AdaptiveConcurrency) ClearEnabled 

func (x *AdaptiveConcurrency) ClearEnabled()

func (*AdaptiveConcurrency) ClearGradientControllerConfig 

func (x *AdaptiveConcurrency) ClearGradientControllerConfig()

func (*AdaptiveConcurrency) GetConcurrencyControllerConfig 

func (x *AdaptiveConcurrency) GetConcurrencyControllerConfig() isAdaptiveConcurrency_ConcurrencyControllerConfig

func (*AdaptiveConcurrency) GetEnabled 

func (x *AdaptiveConcurrency) GetEnabled() *core.RuntimeFeatureFlag

func (*AdaptiveConcurrency) GetGradientControllerConfig 

func (x *AdaptiveConcurrency) GetGradientControllerConfig() *GradientControllerConfig

func (*AdaptiveConcurrency) HasConcurrencyControllerConfig 

func (x *AdaptiveConcurrency) HasConcurrencyControllerConfig() bool

func (*AdaptiveConcurrency) HasEnabled 

func (x *AdaptiveConcurrency) HasEnabled() bool

func (*AdaptiveConcurrency) HasGradientControllerConfig 

func (x *AdaptiveConcurrency) HasGradientControllerConfig() bool

func (*AdaptiveConcurrency) ProtoMessage 

func (*AdaptiveConcurrency) ProtoMessage()

func (*AdaptiveConcurrency) ProtoReflect 

func (x *AdaptiveConcurrency) ProtoReflect() protoreflect.Message

func (*AdaptiveConcurrency) Reset 

func (x *AdaptiveConcurrency) Reset()

func (*AdaptiveConcurrency) SetEnabled 

func (x *AdaptiveConcurrency) SetEnabled(v *core.RuntimeFeatureFlag)

func (*AdaptiveConcurrency) SetGradientControllerConfig 

func (x *AdaptiveConcurrency) SetGradientControllerConfig(v *GradientControllerConfig)

func (*AdaptiveConcurrency) String 

func (x *AdaptiveConcurrency) String() string

func (*AdaptiveConcurrency) WhichConcurrencyControllerConfig 

func (x *AdaptiveConcurrency) WhichConcurrencyControllerConfig() case_AdaptiveConcurrency_ConcurrencyControllerConfig

type AdaptiveConcurrency_GradientControllerConfig 

type AdaptiveConcurrency_GradientControllerConfig struct {
	// Gradient concurrency control will be used.
	GradientControllerConfig *GradientControllerConfig `protobuf:"bytes,1,opt,name=gradient_controller_config,json=gradientControllerConfig,proto3,oneof"`
}

type AdaptiveConcurrency_builder 

type AdaptiveConcurrency_builder struct {

	// Fields of oneof ConcurrencyControllerConfig:
	// Gradient concurrency control will be used.
	GradientControllerConfig *GradientControllerConfig
	// -- end of ConcurrencyControllerConfig
	// If set to false, the adaptive concurrency filter will operate as a pass-through filter. If the
	// message is unspecified, the filter will be enabled.
	Enabled *core.RuntimeFeatureFlag
	// contains filtered or unexported fields
}

func (AdaptiveConcurrency_builder) Build 

func (b0 AdaptiveConcurrency_builder) Build() *AdaptiveConcurrency

type GradientControllerConfig 

type GradientControllerConfig struct {

	// The percentile to use when summarizing aggregated samples. Defaults to p50.
	SampleAggregatePercentile *_type.Percent                                              `` /* 138-byte string literal not displayed */
	ConcurrencyLimitParams    *GradientControllerConfig_ConcurrencyLimitCalculationParams `` /* 129-byte string literal not displayed */
	MinRttCalcParams          *GradientControllerConfig_MinimumRTTCalculationParams       `protobuf:"bytes,3,opt,name=min_rtt_calc_params,json=minRttCalcParams,proto3" json:"min_rtt_calc_params,omitempty"`
	// contains filtered or unexported fields
}

Configuration parameters for the gradient controller.

func (*GradientControllerConfig) ClearConcurrencyLimitParams 

func (x *GradientControllerConfig) ClearConcurrencyLimitParams()

func (*GradientControllerConfig) ClearMinRttCalcParams 

func (x *GradientControllerConfig) ClearMinRttCalcParams()

func (*GradientControllerConfig) ClearSampleAggregatePercentile 

func (x *GradientControllerConfig) ClearSampleAggregatePercentile()

func (*GradientControllerConfig) GetConcurrencyLimitParams 

func (x *GradientControllerConfig) GetConcurrencyLimitParams() *GradientControllerConfig_ConcurrencyLimitCalculationParams

func (*GradientControllerConfig) GetMinRttCalcParams 

func (x *GradientControllerConfig) GetMinRttCalcParams() *GradientControllerConfig_MinimumRTTCalculationParams

func (*GradientControllerConfig) GetSampleAggregatePercentile 

func (x *GradientControllerConfig) GetSampleAggregatePercentile() *_type.Percent

func (*GradientControllerConfig) HasConcurrencyLimitParams 

func (x *GradientControllerConfig) HasConcurrencyLimitParams() bool

func (*GradientControllerConfig) HasMinRttCalcParams 

func (x *GradientControllerConfig) HasMinRttCalcParams() bool

func (*GradientControllerConfig) HasSampleAggregatePercentile 

func (x *GradientControllerConfig) HasSampleAggregatePercentile() bool

func (*GradientControllerConfig) ProtoMessage 

func (*GradientControllerConfig) ProtoMessage()

func (*GradientControllerConfig) ProtoReflect 

func (x *GradientControllerConfig) ProtoReflect() protoreflect.Message

func (*GradientControllerConfig) Reset 

func (x *GradientControllerConfig) Reset()

func (*GradientControllerConfig) SetConcurrencyLimitParams 

func (x *GradientControllerConfig) SetConcurrencyLimitParams(v *GradientControllerConfig_ConcurrencyLimitCalculationParams)

func (*GradientControllerConfig) SetMinRttCalcParams 

func (x *GradientControllerConfig) SetMinRttCalcParams(v *GradientControllerConfig_MinimumRTTCalculationParams)

func (*GradientControllerConfig) SetSampleAggregatePercentile 

func (x *GradientControllerConfig) SetSampleAggregatePercentile(v *_type.Percent)

func (*GradientControllerConfig) String 

func (x *GradientControllerConfig) String() string

type GradientControllerConfig_ConcurrencyLimitCalculationParams 

type GradientControllerConfig_ConcurrencyLimitCalculationParams struct {

	// The allowed upper-bound on the calculated concurrency limit. Defaults to 1000.
	MaxConcurrencyLimit *wrapperspb.UInt32Value `protobuf:"bytes,2,opt,name=max_concurrency_limit,json=maxConcurrencyLimit,proto3" json:"max_concurrency_limit,omitempty"`
	// The period of time samples are taken to recalculate the concurrency limit.
	ConcurrencyUpdateInterval *durationpb.Duration `` /* 138-byte string literal not displayed */
	// contains filtered or unexported fields
}

Parameters controlling the periodic recalculation of the concurrency limit from sampled request latencies.

func (*GradientControllerConfig_ConcurrencyLimitCalculationParams) ClearConcurrencyUpdateInterval 

func (x *GradientControllerConfig_ConcurrencyLimitCalculationParams) ClearConcurrencyUpdateInterval()

func (*GradientControllerConfig_ConcurrencyLimitCalculationParams) ClearMaxConcurrencyLimit 

func (x *GradientControllerConfig_ConcurrencyLimitCalculationParams) ClearMaxConcurrencyLimit()

func (*GradientControllerConfig_ConcurrencyLimitCalculationParams) GetConcurrencyUpdateInterval 

func (x *GradientControllerConfig_ConcurrencyLimitCalculationParams) GetConcurrencyUpdateInterval() *durationpb.Duration

func (*GradientControllerConfig_ConcurrencyLimitCalculationParams) GetMaxConcurrencyLimit 

func (x *GradientControllerConfig_ConcurrencyLimitCalculationParams) GetMaxConcurrencyLimit() *wrapperspb.UInt32Value

func (*GradientControllerConfig_ConcurrencyLimitCalculationParams) HasConcurrencyUpdateInterval 

func (x *GradientControllerConfig_ConcurrencyLimitCalculationParams) HasConcurrencyUpdateInterval() bool

func (*GradientControllerConfig_ConcurrencyLimitCalculationParams) HasMaxConcurrencyLimit 

func (x *GradientControllerConfig_ConcurrencyLimitCalculationParams) HasMaxConcurrencyLimit() bool

func (*GradientControllerConfig_ConcurrencyLimitCalculationParams) ProtoMessage 

func (*GradientControllerConfig_ConcurrencyLimitCalculationParams) ProtoMessage()

func (*GradientControllerConfig_ConcurrencyLimitCalculationParams) ProtoReflect 

func (x *GradientControllerConfig_ConcurrencyLimitCalculationParams) ProtoReflect() protoreflect.Message

func (*GradientControllerConfig_ConcurrencyLimitCalculationParams) Reset 

func (x *GradientControllerConfig_ConcurrencyLimitCalculationParams) Reset()

func (*GradientControllerConfig_ConcurrencyLimitCalculationParams) SetConcurrencyUpdateInterval 

func (x *GradientControllerConfig_ConcurrencyLimitCalculationParams) SetConcurrencyUpdateInterval(v *durationpb.Duration)

func (*GradientControllerConfig_ConcurrencyLimitCalculationParams) SetMaxConcurrencyLimit 

func (x *GradientControllerConfig_ConcurrencyLimitCalculationParams) SetMaxConcurrencyLimit(v *wrapperspb.UInt32Value)

func (*GradientControllerConfig_ConcurrencyLimitCalculationParams) String 

func (x *GradientControllerConfig_ConcurrencyLimitCalculationParams) String() string

type GradientControllerConfig_ConcurrencyLimitCalculationParams_builder 

type GradientControllerConfig_ConcurrencyLimitCalculationParams_builder struct {

	// The allowed upper-bound on the calculated concurrency limit. Defaults to 1000.
	MaxConcurrencyLimit *wrapperspb.UInt32Value
	// The period of time samples are taken to recalculate the concurrency limit.
	ConcurrencyUpdateInterval *durationpb.Duration
	// contains filtered or unexported fields
}

func (GradientControllerConfig_ConcurrencyLimitCalculationParams_builder) Build 

func (b0 GradientControllerConfig_ConcurrencyLimitCalculationParams_builder) Build() *GradientControllerConfig_ConcurrencyLimitCalculationParams

type GradientControllerConfig_MinimumRTTCalculationParams 

type GradientControllerConfig_MinimumRTTCalculationParams struct {

	// The time interval between recalculating the minimum request round-trip time.
	Interval *durationpb.Duration `protobuf:"bytes,1,opt,name=interval,proto3" json:"interval,omitempty"`
	// The number of requests to aggregate/sample during the minRTT recalculation window before
	// updating. Defaults to 50.
	RequestCount *wrapperspb.UInt32Value `protobuf:"bytes,2,opt,name=request_count,json=requestCount,proto3" json:"request_count,omitempty"`
	// Randomized time delta that will be introduced to the start of the minRTT calculation window.
	// This is represented as a percentage of the interval duration. Defaults to 15%.
	//
	// Example: If the interval is 10s and the jitter is 15%, the next window will begin
	// somewhere in the range (10s - 11.5s).
	Jitter *_type.Percent `protobuf:"bytes,3,opt,name=jitter,proto3" json:"jitter,omitempty"`
	// The concurrency limit set while measuring the minRTT. Defaults to 3.
	MinConcurrency *wrapperspb.UInt32Value `protobuf:"bytes,4,opt,name=min_concurrency,json=minConcurrency,proto3" json:"min_concurrency,omitempty"`
	// Amount added to the measured minRTT to add stability to the concurrency limit during natural
	// variability in latency. This is expressed as a percentage of the measured value and can be
	// adjusted to allow more or less tolerance to the sampled latency values.
	//
	// Defaults to 25%.
	Buffer *_type.Percent `protobuf:"bytes,5,opt,name=buffer,proto3" json:"buffer,omitempty"`
	// contains filtered or unexported fields
}

Parameters controlling the periodic minRTT recalculation. [#next-free-field: 6]

func (*GradientControllerConfig_MinimumRTTCalculationParams) ClearBuffer 

func (x *GradientControllerConfig_MinimumRTTCalculationParams) ClearBuffer()

func (*GradientControllerConfig_MinimumRTTCalculationParams) ClearInterval 

func (x *GradientControllerConfig_MinimumRTTCalculationParams) ClearInterval()

func (*GradientControllerConfig_MinimumRTTCalculationParams) ClearJitter 

func (x *GradientControllerConfig_MinimumRTTCalculationParams) ClearJitter()

func (*GradientControllerConfig_MinimumRTTCalculationParams) ClearMinConcurrency 

func (x *GradientControllerConfig_MinimumRTTCalculationParams) ClearMinConcurrency()

func (*GradientControllerConfig_MinimumRTTCalculationParams) ClearRequestCount 

func (x *GradientControllerConfig_MinimumRTTCalculationParams) ClearRequestCount()

func (*GradientControllerConfig_MinimumRTTCalculationParams) GetBuffer 

func (x *GradientControllerConfig_MinimumRTTCalculationParams) GetBuffer() *_type.Percent

func (*GradientControllerConfig_MinimumRTTCalculationParams) GetInterval 

func (x *GradientControllerConfig_MinimumRTTCalculationParams) GetInterval() *durationpb.Duration

func (*GradientControllerConfig_MinimumRTTCalculationParams) GetJitter 

func (x *GradientControllerConfig_MinimumRTTCalculationParams) GetJitter() *_type.Percent

func (*GradientControllerConfig_MinimumRTTCalculationParams) GetMinConcurrency 

func (x *GradientControllerConfig_MinimumRTTCalculationParams) GetMinConcurrency() *wrapperspb.UInt32Value

func (*GradientControllerConfig_MinimumRTTCalculationParams) GetRequestCount 

func (x *GradientControllerConfig_MinimumRTTCalculationParams) GetRequestCount() *wrapperspb.UInt32Value

func (*GradientControllerConfig_MinimumRTTCalculationParams) HasBuffer 

func (x *GradientControllerConfig_MinimumRTTCalculationParams) HasBuffer() bool

func (*GradientControllerConfig_MinimumRTTCalculationParams) HasInterval 

func (x *GradientControllerConfig_MinimumRTTCalculationParams) HasInterval() bool

func (*GradientControllerConfig_MinimumRTTCalculationParams) HasJitter 

func (x *GradientControllerConfig_MinimumRTTCalculationParams) HasJitter() bool

func (*GradientControllerConfig_MinimumRTTCalculationParams) HasMinConcurrency 

func (x *GradientControllerConfig_MinimumRTTCalculationParams) HasMinConcurrency() bool

func (*GradientControllerConfig_MinimumRTTCalculationParams) HasRequestCount 

func (x *GradientControllerConfig_MinimumRTTCalculationParams) HasRequestCount() bool

func (*GradientControllerConfig_MinimumRTTCalculationParams) ProtoMessage 

func (*GradientControllerConfig_MinimumRTTCalculationParams) ProtoMessage()

func (*GradientControllerConfig_MinimumRTTCalculationParams) ProtoReflect 

func (x *GradientControllerConfig_MinimumRTTCalculationParams) ProtoReflect() protoreflect.Message

func (*GradientControllerConfig_MinimumRTTCalculationParams) Reset 

func (x *GradientControllerConfig_MinimumRTTCalculationParams) Reset()

func (*GradientControllerConfig_MinimumRTTCalculationParams) SetBuffer 

func (x *GradientControllerConfig_MinimumRTTCalculationParams) SetBuffer(v *_type.Percent)

func (*GradientControllerConfig_MinimumRTTCalculationParams) SetInterval 

func (x *GradientControllerConfig_MinimumRTTCalculationParams) SetInterval(v *durationpb.Duration)

func (*GradientControllerConfig_MinimumRTTCalculationParams) SetJitter 

func (x *GradientControllerConfig_MinimumRTTCalculationParams) SetJitter(v *_type.Percent)

func (*GradientControllerConfig_MinimumRTTCalculationParams) SetMinConcurrency 

func (x *GradientControllerConfig_MinimumRTTCalculationParams) SetMinConcurrency(v *wrapperspb.UInt32Value)

func (*GradientControllerConfig_MinimumRTTCalculationParams) SetRequestCount 

func (x *GradientControllerConfig_MinimumRTTCalculationParams) SetRequestCount(v *wrapperspb.UInt32Value)

func (*GradientControllerConfig_MinimumRTTCalculationParams) String 

func (x *GradientControllerConfig_MinimumRTTCalculationParams) String() string

type GradientControllerConfig_MinimumRTTCalculationParams_builder 

type GradientControllerConfig_MinimumRTTCalculationParams_builder struct {

	// The time interval between recalculating the minimum request round-trip time.
	Interval *durationpb.Duration
	// The number of requests to aggregate/sample during the minRTT recalculation window before
	// updating. Defaults to 50.
	RequestCount *wrapperspb.UInt32Value
	// Randomized time delta that will be introduced to the start of the minRTT calculation window.
	// This is represented as a percentage of the interval duration. Defaults to 15%.
	//
	// Example: If the interval is 10s and the jitter is 15%, the next window will begin
	// somewhere in the range (10s - 11.5s).
	Jitter *_type.Percent
	// The concurrency limit set while measuring the minRTT. Defaults to 3.
	MinConcurrency *wrapperspb.UInt32Value
	// Amount added to the measured minRTT to add stability to the concurrency limit during natural
	// variability in latency. This is expressed as a percentage of the measured value and can be
	// adjusted to allow more or less tolerance to the sampled latency values.
	//
	// Defaults to 25%.
	Buffer *_type.Percent
	// contains filtered or unexported fields
}

func (GradientControllerConfig_MinimumRTTCalculationParams_builder) Build 

func (b0 GradientControllerConfig_MinimumRTTCalculationParams_builder) Build() *GradientControllerConfig_MinimumRTTCalculationParams

type GradientControllerConfig_builder 

type GradientControllerConfig_builder struct {

	// The percentile to use when summarizing aggregated samples. Defaults to p50.
	SampleAggregatePercentile *_type.Percent
	ConcurrencyLimitParams    *GradientControllerConfig_ConcurrencyLimitCalculationParams
	MinRttCalcParams          *GradientControllerConfig_MinimumRTTCalculationParams
	// contains filtered or unexported fields
}

func (GradientControllerConfig_builder) Build 

func (b0 GradientControllerConfig_builder) Build() *GradientControllerConfig

Source Files

  • adaptive_concurrency.pb.go

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.