func AcquireUpdateInstanceStateShardRequest() *UpdateInstanceStateShardRequest {
	value := updateInstanceStateShardPool.Get()
	if value == nil {
		return &UpdateInstanceStateShardRequest{}
	}
	return value.(*UpdateInstanceStateShardRequest)
}
AcquireUpdateInstanceStateShardRequest returns value from pool
package rpcpb
import (
	"sync"
	"github.com/fagongzi/util/protoc"
)
var (
	EmptyResp = EmptyResponse{}
	EmptyRespBytes = protoc.MustMarshal(&EmptyResp)
	EmptyBytesSliceBytes = protoc.MustMarshal(&BytesSliceResponse{})
	TrueRespBytes = protoc.MustMarshal(&BoolResponse{Value: true})
	FalseRespBytes = protoc.MustMarshal(&BoolResponse{})
)
var (
	setPool                      sync.Pool
	setIfPool                    sync.Pool
	getPool                      sync.Pool
	deletePool                   sync.Pool
	deleteIfPool                 sync.Pool
	scanPool                     sync.Pool
	allocIDPool                  sync.Pool
	resetIDPool                  sync.Pool
	bmCreatePool                 sync.Pool
	bmAddPool                    sync.Pool
	bmRemovePool                 sync.Pool
	bmClearPool                  sync.Pool
	bmContainsPool               sync.Pool
	bmCountPool                  sync.Pool
	bmRangePool                  sync.Pool
	startingInstancePool         sync.Pool
	startedInstancePool          sync.Pool
	stopInstancePool             sync.Pool
	stoppedInstancePool          sync.Pool
	createInstanceStateShardPool sync.Pool
	updateInstanceStateShardPool sync.Pool
	removeInstanceStateShardPool sync.Pool
	queueAddPool                 sync.Pool
	queueFetchPool               sync.Pool
	queueJoinPool                sync.Pool
	queueScanPool                sync.Pool
	queueCommitPool              sync.Pool
	queueDeletePool              sync.Pool
	tenantInitPool               sync.Pool
	tenantInitStateUpdatePool    sync.Pool
	updateMappingPool            sync.Pool
	scanMappingPool              sync.Pool
	lockPool                     sync.Pool
	unlockPool                   sync.Pool
	uint64Pool      sync.Pool
	bytesPool       sync.Pool
	boolPool        sync.Pool
	uint32Pool      sync.Pool
	uint32RangePool sync.Pool
	uint32SlicePool sync.Pool
	bytesSlicePool  sync.Pool
	requestPool = sync.Pool{
		New: func() interface{} {
			return &Request{}
		},
	}
	responsePool = sync.Pool{
		New: func() interface{} {
			return &Response{}
		},
	}
)
func AcquireResetIDRequest() *ResetIDRequest {
	value := resetIDPool.Get()
	if value == nil {
		return &ResetIDRequest{}
	}
	return value.(*ResetIDRequest)
}
func ReleaseResetIDRequest(value *ResetIDRequest) {
	value.Reset()
	resetIDPool.Put(value)
}
func AcquireAllocIDRequest() *AllocIDRequest {
	value := allocIDPool.Get()
	if value == nil {
		return &AllocIDRequest{}
	}
	return value.(*AllocIDRequest)
}
func ReleaseAllocIDRequest(value *AllocIDRequest) {
	value.Reset()
	allocIDPool.Put(value)
}
func AcquireUint32RangeResponse() *Uint32RangeResponse {
	value := uint32RangePool.Get()
	if value == nil {
		return &Uint32RangeResponse{}
	}
	return value.(*Uint32RangeResponse)
}
func ReleaseUint32RangeResponse(value *Uint32RangeResponse) {
	value.Reset()
	uint32RangePool.Put(value)
}
func AcquireUint32Response() *Uint32Response {
	value := uint32Pool.Get()
	if value == nil {
		return &Uint32Response{}
	}
	return value.(*Uint32Response)
}
func ReleaseUint32Response(value *Uint32Response) {
	value.Reset()
	uint32Pool.Put(value)
}
func AcquireRequest() *Request {
	return requestPool.Get().(*Request)
}
func ReleaseRequest(value *Request) {
	value.Reset()
	requestPool.Put(value)
}
func AcquireResponse() *Response {
	return responsePool.Get().(*Response)
}
func ReleaseResponse(value *Response) {
	value.Reset()
	responsePool.Put(value)
}
func AcquireTenantInitRequest() *TenantInitRequest {
	value := tenantInitPool.Get()
	if value == nil {
		return &TenantInitRequest{}
	}
	return value.(*TenantInitRequest)
}
func ReleaseTenantInitRequest(value *TenantInitRequest) {
	value.Reset()
	tenantInitPool.Put(value)
}
func AcquireTenantInitStateUpdateRequest() *TenantInitStateUpdateRequest {
	value := tenantInitStateUpdatePool.Get()
	if value == nil {
		return &TenantInitStateUpdateRequest{}
	}
	return value.(*TenantInitStateUpdateRequest)
}
func ReleaseTenantInitStateUpdateRequest(value *TenantInitStateUpdateRequest) {
	value.Reset()
	tenantInitStateUpdatePool.Put(value)
}
func AcquireBytesSliceResponse() *BytesSliceResponse {
	value := bytesSlicePool.Get()
	if value == nil {
		return &BytesSliceResponse{}
	}
	return value.(*BytesSliceResponse)
}
func ReleaseBytesSliceResponse(value *BytesSliceResponse) {
	value.Reset()
	bytesSlicePool.Put(value)
}
func AcquireUint32SliceResponse() *Uint32SliceResponse {
	value := uint32SlicePool.Get()
	if value == nil {
		return &Uint32SliceResponse{}
	}
	return value.(*Uint32SliceResponse)
}
func ReleaseUint32SliceResponse(value *Uint32SliceResponse) {
	value.Reset()
	uint32SlicePool.Put(value)
}
func AcquireBoolResponse() *BoolResponse {
	value := boolPool.Get()
	if value == nil {
		return &BoolResponse{}
	}
	return value.(*BoolResponse)
}
func ReleaseBoolResponse(value *BoolResponse) {
	value.Reset()
	boolPool.Put(value)
}
func AcquireBytesResponse() *BytesResponse {
	value := bytesPool.Get()
	if value == nil {
		return &BytesResponse{}
	}
	return value.(*BytesResponse)
}
func ReleaseBytesResponse(value *BytesResponse) {
	value.Reset()
	bytesPool.Put(value)
}
func AcquireUint64Response() *Uint64Response {
	value := uint64Pool.Get()
	if value == nil {
		return &Uint64Response{}
	}
	return value.(*Uint64Response)
}
func ReleaseUint64Response(value *Uint64Response) {
	value.Reset()
	uint64Pool.Put(value)
}
func AcquireSetRequest() *SetRequest {
	value := setPool.Get()
	if value == nil {
		return &SetRequest{}
	}
	return value.(*SetRequest)
}
func ReleaseSetRequest(value *SetRequest) {
	value.Reset()
	setPool.Put(value)
}
func AcquireSetIfRequest() *SetIfRequest {
	value := setIfPool.Get()
	if value == nil {
		return &SetIfRequest{}
	}
	return value.(*SetIfRequest)
}
func ReleaseSetIfRequest(value *SetIfRequest) {
	value.Reset()
	setIfPool.Put(value)
}
func AcquireGetRequest() *GetRequest {
	value := getPool.Get()
	if value == nil {
		return &GetRequest{}
	}
	return value.(*GetRequest)
}
func ReleaseGetRequest(value *GetRequest) {
	value.Reset()
	getPool.Put(value)
}
func AcquireDeleteRequest() *DeleteRequest {
	value := deletePool.Get()
	if value == nil {
		return &DeleteRequest{}
	}
	return value.(*DeleteRequest)
}
func ReleaseDeleteRequest(value *DeleteRequest) {
	value.Reset()
	deletePool.Put(value)
}
func AcquireDeleteIfRequest() *DeleteIfRequest {
	value := deleteIfPool.Get()
	if value == nil {
		return &DeleteIfRequest{}
	}
	return value.(*DeleteIfRequest)
}
func ReleaseDeleteIfRequest(value *DeleteIfRequest) {
	value.Reset()
	deleteIfPool.Put(value)
}
func AcquireScanRequest() *ScanRequest {
	value := scanPool.Get()
	if value == nil {
		return &ScanRequest{}
	}
	return value.(*ScanRequest)
}
func ReleaseScanRequest(value *ScanRequest) {
	value.Reset()
	scanPool.Put(value)
}
func AcquireBMCreateRequest() *BMCreateRequest {
	value := bmCreatePool.Get()
	if value == nil {
		return &BMCreateRequest{}
	}
	return value.(*BMCreateRequest)
}
func ReleaseBMCreateRequest(value *BMCreateRequest) {
	value.Reset()
	bmCreatePool.Put(value)
}
func AcquireBMAddRequest() *BMAddRequest {
	value := bmAddPool.Get()
	if value == nil {
		return &BMAddRequest{}
	}
	return value.(*BMAddRequest)
}
func ReleaseBMAddRequest(value *BMAddRequest) {
	value.Reset()
	bmAddPool.Put(value)
}
func AcquireBMRemoveRequest() *BMRemoveRequest {
	value := bmRemovePool.Get()
	if value == nil {
		return &BMRemoveRequest{}
	}
	return value.(*BMRemoveRequest)
}
func ReleaseBMRemoveRequest(value *BMRemoveRequest) {
	value.Reset()
	bmRemovePool.Put(value)
}
func AcquireBMClearRequest() *BMClearRequest {
	value := bmClearPool.Get()
	if value == nil {
		return &BMClearRequest{}
	}
	return value.(*BMClearRequest)
}
func ReleaseBMClearRequest(value *BMClearRequest) {
	value.Reset()
	bmClearPool.Put(value)
}
func AcquireBMContainsRequest() *BMContainsRequest {
	value := bmContainsPool.Get()
	if value == nil {
		return &BMContainsRequest{}
	}
	return value.(*BMContainsRequest)
}
func ReleaseBMContainsRequest(value *BMContainsRequest) {
	value.Reset()
	bmContainsPool.Put(value)
}
func AcquireBMCountRequest() *BMCountRequest {
	value := bmCountPool.Get()
	if value == nil {
		return &BMCountRequest{}
	}
	return value.(*BMCountRequest)
}
func ReleaseBMCountRequest(value *BMCountRequest) {
	value.Reset()
	bmCountPool.Put(value)
}
func AcquireBMRangeRequest() *BMRangeRequest {
	value := bmRangePool.Get()
	if value == nil {
		return &BMRangeRequest{}
	}
	return value.(*BMRangeRequest)
}
func ReleaseBMRangeRequest(value *BMRangeRequest) {
	value.Reset()
	bmRangePool.Put(value)
}
func AcquireQueueAddRequest() *QueueAddRequest {
	value := queueAddPool.Get()
	if value == nil {
		return &QueueAddRequest{}
	}
	return value.(*QueueAddRequest)
}
func ReleaseQueueAddRequest(value *QueueAddRequest) {
	value.Reset()
	queueAddPool.Put(value)
}
func AcquireQueueFetchRequest() *QueueFetchRequest {
	value := queueFetchPool.Get()
	if value == nil {
		return &QueueFetchRequest{}
	}
	return value.(*QueueFetchRequest)
}
func ReleaseQueueFetchRequest(value *QueueFetchRequest) {
	value.Reset()
	queueFetchPool.Put(value)
}
func AcquireQueueJoinGroupRequest() *QueueJoinGroupRequest {
	value := queueJoinPool.Get()
	if value == nil {
		return &QueueJoinGroupRequest{}
	}
	return value.(*QueueJoinGroupRequest)
}
func ReleaseQueueJoinGroupRequest(value *QueueJoinGroupRequest) {
	value.Reset()
	queueJoinPool.Put(value)
}
func AcquireQueueScanRequest() *QueueScanRequest {
	value := queueScanPool.Get()
	if value == nil {
		return &QueueScanRequest{}
	}
	return value.(*QueueScanRequest)
}
func ReleaseQueueScanRequest(value *QueueScanRequest) {
	value.Reset()
	queueScanPool.Put(value)
}
func AcquireQueueCommitRequest() *QueueCommitRequest {
	value := queueCommitPool.Get()
	if value == nil {
		return &QueueCommitRequest{}
	}
	return value.(*QueueCommitRequest)
}
func ReleaseQueueCommitRequest(value *QueueCommitRequest) {
	value.Reset()
	queueCommitPool.Put(value)
}
func AcquireQueueDeleteRequest() *QueueDeleteRequest {
	value := queueDeletePool.Get()
	if value == nil {
		return &QueueDeleteRequest{}
	}
	return value.(*QueueDeleteRequest)
}
func ReleaseQueueDeleteRequest(value *QueueDeleteRequest) {
	value.Reset()
	queueDeletePool.Put(value)
}
func AcquireUpdateMappingRequest() *UpdateMappingRequest {
	value := updateMappingPool.Get()
	if value == nil {
		return &UpdateMappingRequest{}
	}
	return value.(*UpdateMappingRequest)
}
func ReleaseUpdateMappingRequest(value *UpdateMappingRequest) {
	value.Reset()
	updateMappingPool.Put(value)
}
func AcquireScanMappingRequest() *ScanMappingRequest {
	value := scanMappingPool.Get()
	if value == nil {
		return &ScanMappingRequest{}
	}
	return value.(*ScanMappingRequest)
}
func ReleaseScanMappingRequest(value *ScanMappingRequest) {
	value.Reset()
	scanMappingPool.Put(value)
}
func AcquireStartingInstanceRequest() *StartingInstanceRequest {
	value := startingInstancePool.Get()
	if value == nil {
		return &StartingInstanceRequest{}
	}
	return value.(*StartingInstanceRequest)
}
func ReleaseStartingInstanceRequest(value *StartingInstanceRequest) {
	value.Reset()
	startingInstancePool.Put(value)
}
func AcquireStartedInstanceRequest() *StartedInstanceRequest {
	value := startedInstancePool.Get()
	if value == nil {
		return &StartedInstanceRequest{}
	}
	return value.(*StartedInstanceRequest)
}
func ReleaseStartedInstanceRequest(value *StartedInstanceRequest) {
	value.Reset()
	startedInstancePool.Put(value)
}
func AcquireStopInstanceRequest() *StopInstanceRequest {
	value := stopInstancePool.Get()
	if value == nil {
		return &StopInstanceRequest{}
	}
	return value.(*StopInstanceRequest)
}
func ReleaseStopInstanceRequest(value *StopInstanceRequest) {
	value.Reset()
	stopInstancePool.Put(value)
}
func AcquireStoppedInstanceRequest() *StoppedInstanceRequest {
	value := stoppedInstancePool.Get()
	if value == nil {
		return &StoppedInstanceRequest{}
	}
	return value.(*StoppedInstanceRequest)
}
func ReleaseStoppedInstanceRequest(value *StoppedInstanceRequest) {
	value.Reset()
	stoppedInstancePool.Put(value)
}
func AcquireCreateInstanceStateShardRequest() *CreateInstanceStateShardRequest {
	value := createInstanceStateShardPool.Get()
	if value == nil {
		return &CreateInstanceStateShardRequest{}
	}
	return value.(*CreateInstanceStateShardRequest)
}
func ReleaseCreateInstanceStateShardRequest(value *CreateInstanceStateShardRequest) {
	value.Reset()
	createInstanceStateShardPool.Put(value)
}