func AcquireBMCreateRequest() *BMCreateRequest {
	value := bmCreatePool.Get()
	if value == nil {
		return &BMCreateRequest{}
	}
	return value.(*BMCreateRequest)
}
AcquireBMCreateRequest 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)
}