Improve pooling and time retrieval mechanism to optimize performance (#155)

louyuting · web-flow · commit 9967812a0f1a · 2020-06-04T20:50:46.000+08:00
* Add pooling mechanism for api.EntryOptions
* Optimize EntryContext pooling
* Improve the logic of getting current time: use cached time by default instead of time.Now(), which might be slow in some circumstances
diff --git a/api/api.go b/api/api.go
@@ -1,9 +1,25 @@
 package api
 
 import (
+	"sync"
+
 	"github.com/alibaba/sentinel-golang/core/base"
 )
 
+var entryOptsPool = sync.Pool{
+	New: func() interface{} {
+		return &EntryOptions{
+			resourceType: base.ResTypeCommon,
+			entryType:    base.Outbound,
+			acquireCount: 1,
+			flag:         0,
+			slotChain:    nil,
+			args:         nil,
+			attachments:  nil,
+		}
+	},
+}
+
 // EntryOptions represents the options of a Sentinel resource entry.
 type EntryOptions struct {
 	resourceType base.ResourceType
@@ -15,6 +31,16 @@ type EntryOptions struct {
 	attachments  map[interface{}]interface{}
 }
 
+func (o *EntryOptions) Reset() {
+	o.resourceType = base.ResTypeCommon
+	o.entryType = base.Outbound
+	o.acquireCount = 1
+	o.flag = 0
+	o.slotChain = nil
+	o.args = nil
+	o.attachments = nil
+}
+
 type EntryOption func(*EntryOptions)
 
 // WithResourceType sets the resource entry with the given resource type.
@@ -55,13 +81,19 @@ func WithArgs(args ...interface{}) EntryOption {
 // WithAttachment set the resource entry with the given k-v pair
 func WithAttachment(key interface{}, value interface{}) EntryOption {
 	return func(opts *EntryOptions) {
+		if opts.attachments == nil {
+			opts.attachments = make(map[interface{}]interface{})
+		}
 		opts.attachments[key] = value
 	}
 }
 
 // WithAttachment set the resource entry with the given k-v pairs
 func WithAttachments(data map[interface{}]interface{}) EntryOption {
 	return func(opts *EntryOptions) {
+		if opts.attachments == nil {
+			opts.attachments = make(map[interface{}]interface{})
+		}
 		for key, value := range data {
 			opts.attachments[key] = value
 		}
@@ -70,20 +102,14 @@ func WithAttachments(data map[interface{}]interface{}) EntryOption {
 
 // Entry is the basic API of Sentinel.
 func Entry(resource string, opts ...EntryOption) (*base.SentinelEntry, *base.BlockError) {
-	var options = EntryOptions{
-		resourceType: base.ResTypeCommon,
-		entryType:    base.Outbound,
-		acquireCount: 1,
-		flag:         0,
-		slotChain:    globalSlotChain,
-		args:         []interface{}{},
-		attachments:  make(map[interface{}]interface{}),
-	}
+	options := entryOptsPool.Get().(*EntryOptions)
+	options.slotChain = globalSlotChain
+
 	for _, opt := range opts {
-		opt(&options)
+		opt(options)
 	}
 
-	return entry(resource, &options)
+	return entry(resource, options)
 }
 
 func entry(resource string, options *EntryOptions) (*base.SentinelEntry, *base.BlockError) {
@@ -96,14 +122,16 @@ func entry(resource string, options *EntryOptions) (*base.SentinelEntry, *base.B
 	// Get context from pool.
 	ctx := sc.GetPooledContext()
 	ctx.Resource = rw
-	ctx.Input = &base.SentinelInput{
-		AcquireCount: options.acquireCount,
-		Flag:         options.flag,
-		Args:         options.args,
-		Attachments:  options.attachments,
+	ctx.Input.AcquireCount = options.acquireCount
+	ctx.Input.Flag = options.flag
+	if len(options.args) != 0 {
+		ctx.Input.Args = options.args
 	}
-	ctx.Data = make(map[interface{}]interface{})
-
+	if len(options.attachments) != 0 {
+		ctx.Input.Attachments = options.attachments
+	}
+	options.Reset()
+	entryOptsPool.Put(options)
 	e := base.NewSentinelEntry(ctx, rw, sc)
 	r := sc.Entry(ctx)
 	if r == nil {
diff --git a/api/init.go b/api/init.go
@@ -6,6 +6,7 @@ import (
 	"github.com/alibaba/sentinel-golang/core/config"
 	"github.com/alibaba/sentinel-golang/core/log/metric"
 	"github.com/alibaba/sentinel-golang/core/system"
+	"github.com/alibaba/sentinel-golang/util"
 )
 
 // InitDefault initializes Sentinel using the configuration from system
@@ -43,5 +44,8 @@ func initCoreComponents() (err error) {
 	}
 
 	system.InitCollector(config.SystemStatCollectIntervalMs())
+	if config.UseCacheTime() {
+		util.StartTimeTicker()
+	}
 	return err
 }
diff --git a/core/base/context.go b/core/base/context.go
@@ -65,12 +65,14 @@ type SentinelInput struct {
 	Attachments map[interface{}]interface{}
 }
 
-func newEmptyInput() *SentinelInput {
-	return &SentinelInput{
-		AcquireCount: 1,
-		Flag:         0,
-		Args:         make([]interface{}, 0, 0),
-		Attachments:  make(map[interface{}]interface{}),
+func (i *SentinelInput) reset() {
+	i.AcquireCount = 1
+	i.Flag = 0
+	if len(i.Args) != 0 {
+		i.Args = make([]interface{}, 0)
+	}
+	if len(i.Attachments) != 0 {
+		i.Attachments = make(map[interface{}]interface{})
 	}
 }
 
@@ -82,11 +84,13 @@ func (ctx *EntryContext) Reset() {
 	ctx.rt = 0
 	ctx.Resource = nil
 	ctx.StatNode = nil
-	ctx.Input = nil
+	ctx.Input.reset()
 	if ctx.RuleCheckResult == nil {
 		ctx.RuleCheckResult = NewTokenResultPass()
 	} else {
 		ctx.RuleCheckResult.ResetToPass()
 	}
-	ctx.Data = nil
+	if len(ctx.Data) != 0 {
+		ctx.Data = make(map[interface{}]interface{})
+	}
 }
diff --git a/core/base/slot_chain.go b/core/base/slot_chain.go
@@ -66,6 +66,13 @@ func NewSlotChain() *SlotChain {
 			New: func() interface{} {
 				ctx := NewEmptyEntryContext()
 				ctx.RuleCheckResult = NewTokenResultPass()
+				ctx.Data = make(map[interface{}]interface{})
+				ctx.Input = &SentinelInput{
+					AcquireCount: 1,
+					Flag:         0,
+					Args:         make([]interface{}, 0),
+					Attachments:  make(map[interface{}]interface{}),
+				}
 				return ctx
 			},
 		},
diff --git a/core/config/config.go b/core/config/config.go
@@ -180,3 +180,7 @@ func MetricLogMaxFileAmount() uint32 {
 func SystemStatCollectIntervalMs() uint32 {
 	return globalCfg.Sentinel.Stat.System.CollectIntervalMs
 }
+
+func UseCacheTime() bool {
+	return globalCfg.Sentinel.UseCacheTime
+}
diff --git a/core/config/entity.go b/core/config/entity.go
@@ -23,6 +23,8 @@ type SentinelConfig struct {
 	Log LogConfig
 	// Stat represents configuration items related to statistics.
 	Stat StatConfig
+	// UseCacheTime indicates whether to cache time(ms)
+	UseCacheTime bool `yaml:"useCacheTime"`
 }
 
 // LogConfig represent the configuration of logging in Sentinel.
@@ -79,6 +81,7 @@ func NewDefaultConfig() *Entity {
 					CollectIntervalMs: DefaultSystemStatCollectIntervalMs,
 				},
 			},
+			UseCacheTime: true,
 		},
 	}
 }
diff --git a/util/time.go b/util/time.go
@@ -24,6 +24,10 @@ func FormatDate(tsMillis uint64) string {
 
 // Returns the current Unix timestamp in milliseconds.
 func CurrentTimeMillis() uint64 {
+	tickerNow := CurrentTimeMillWithTicker()
+	if tickerNow > uint64(0) {
+		return tickerNow
+	}
 	return uint64(time.Now().UnixNano()) / UnixTimeUnitOffset
 }
 
diff --git a/util/time_test.go b/util/time_test.go
@@ -91,3 +91,19 @@ func TestCurrentTimeNano(t *testing.T) {
 	got := CurrentTimeNano()
 	fmt.Println(got)
 }
+
+func BenchmarkCurrentTimeInMs(b *testing.B) {
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		CurrentTimeMillis()
+	}
+}
+
+func BenchmarkCurrentTimeInMsWithTicker(b *testing.B) {
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		CurrentTimeMillWithTicker()
+	}
+}
diff --git a/util/time_ticker.go b/util/time_ticker.go
@@ -0,0 +1,23 @@
+package util
+
+import (
+	"sync/atomic"
+	"time"
+)
+
+var nowInMs = uint64(0)
+
+func StartTimeTicker() {
+	atomic.StoreUint64(&nowInMs, uint64(time.Now().UnixNano())/UnixTimeUnitOffset)
+	go func() {
+		for {
+			now := uint64(time.Now().UnixNano()) / UnixTimeUnitOffset
+			atomic.StoreUint64(&nowInMs, now)
+			time.Sleep(time.Millisecond)
+		}
+	}()
+}
+
+func CurrentTimeMillWithTicker() uint64 {
+	return atomic.LoadUint64(&nowInMs)
+}
diff --git a/util/util_test.go b/util/util_test.go

Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@ import (`
`6`	`6`	`"github.com/alibaba/sentinel-golang/core/config"`
`7`	`7`	`"github.com/alibaba/sentinel-golang/core/log/metric"`
`8`	`8`	`"github.com/alibaba/sentinel-golang/core/system"`
	`9`	`+ "github.com/alibaba/sentinel-golang/util"`
`9`	`10`	`)`
`10`	`11`
`11`	`12`	`// InitDefault initializes Sentinel using the configuration from system`
`@@ -43,5 +44,8 @@ func initCoreComponents() (err error) {`
`43`	`44`	`}`
`44`	`45`
`45`	`46`	`system.InitCollector(config.SystemStatCollectIntervalMs())`
	`47`	`+ if config.UseCacheTime() {`
	`48`	`+ util.StartTimeTicker()`
	`49`	`+ }`
`46`	`50`	`return err`
`47`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -180,3 +180,7 @@ func MetricLogMaxFileAmount() uint32 {`
`180`	`180`	`func SystemStatCollectIntervalMs() uint32 {`
`181`	`181`	`return globalCfg.Sentinel.Stat.System.CollectIntervalMs`
`182`	`182`	`}`
	`183`	`+`
	`184`	`+func UseCacheTime() bool {`
	`185`	`+ return globalCfg.Sentinel.UseCacheTime`
	`186`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -23,6 +23,8 @@ type SentinelConfig struct {`
`23`	`23`	`Log LogConfig`
`24`	`24`	`// Stat represents configuration items related to statistics.`
`25`	`25`	`Stat StatConfig`
	`26`	`+ // UseCacheTime indicates whether to cache time(ms)`
	`27`	+ UseCacheTime bool `yaml:"useCacheTime"`
`26`	`28`	`}`
`27`	`29`
`28`	`30`	`// LogConfig represent the configuration of logging in Sentinel.`
`@@ -79,6 +81,7 @@ func NewDefaultConfig() *Entity {`
`79`	`81`	`CollectIntervalMs: DefaultSystemStatCollectIntervalMs,`
`80`	`82`	`},`
`81`	`83`	`},`
	`84`	`+ UseCacheTime: true,`
`82`	`85`	`},`
`83`	`86`	`}`
`84`	`87`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,6 +24,10 @@ func FormatDate(tsMillis uint64) string {`
`24`	`24`
`25`	`25`	`// Returns the current Unix timestamp in milliseconds.`
`26`	`26`	`func CurrentTimeMillis() uint64 {`
	`27`	`+ tickerNow := CurrentTimeMillWithTicker()`
	`28`	`+ if tickerNow > uint64(0) {`
	`29`	`+ return tickerNow`
	`30`	`+ }`
`27`	`31`	`return uint64(time.Now().UnixNano()) / UnixTimeUnitOffset`
`28`	`32`	`}`
`29`	`33`