@@ -193,15 +193,33 @@ func DoNotify(userIds []string, source, targetId int, targetTime int64) {
        defer sp.Finish()
        ctx := context.WithValue(context.Background(), trace.CDTCtxKey, sp.Context())

+       const MAX = 100
+
        syncData := map[string]interface{}{
                "source":      source,
                "target_id":   strconv.Itoa(targetId),
                "target_time": targetTime,
        }
-       rsp, err := external.BatchSyncNotify(ctx, userIds, syncData)
-       if err != nil {
-               clog.Logger.Error("DoNotify error:%s rsp:%+v", err, rsp)
+
+       if len(userIds) == 1 {
+               rsp, err := external.SingleSyncNotify(ctx, userIds[0], syncData)
+               if err != nil {
+                       clog.Logger.Error("DoNotify error:%s rsp:%+v", err, rsp)
+               }
+       } else {
+               for i := 0; i < len(userIds); {
+                       j := i + MAX
+                       if j > len(userIds) {
+                               j = len(userIds)
+                       }
+                       us := userIds[i:j]
+                       rsp, err := external.BatchSyncNotify(ctx, us, syncData)
+                       if err != nil {
+                               clog.Logger.Error("DoNotify error:%s rsp:%+v", err, rsp)
+                       }
+                       i = j
+               }
        }
-       clog.Logger.Debug("DoNotify success user_num:%d rsp:%+v", len(userIds), rsp)
+
        return
 }

@@ -1304,12 +1304,13 @@ func (b *BatchTask) Run(timeout time.Duration) (timed bool) {
        }
        b.TaskList.Range(p)
        after := time.After(timeout)
-       ticker := time.Tick(time.Millisecond * 200)
+       ticker := time.NewTicker(time.Millisecond * 200)
+       defer ticker.Stop()
        for {
                select {
                case <-after:
                        return true
-               case <-ticker:
+               case <-ticker.C:
                        i := 0
                        b.TaskList.Range(func(k, v interface{}) bool {
                                i++

package utils

import (
	"backend/framework/log"
	"sync"
)

type RawMem [4]int64

var GUseMemPool bool
var MinSize int = 100
var MaxSize int = 100 * 1024
var MaxSensor int = 1000000

var MemPool *SyncPool

func InitPool() {
	MemPool = NewSyncPool(MinSize, MaxSize, 2)
	log.Info("init pool")
}

// SyncPool is a sync.Pool base slab allocation memory pool
type SyncPool struct {
	classes     []sync.Pool
	classesSize []int
	minSize     int
	maxSize     int
}

// NewSyncPool create a sync.Pool base slab allocation memory pool.
// minSize is the smallest chunk size.
// maxSize is the lagest chunk size.
// factor is used to control growth of chunk size.
func NewSyncPool(minSize, maxSize, factor int) *SyncPool {
	n := 0
	for chunkSize := minSize; chunkSize <= maxSize; chunkSize *= factor {
		n++
	}
	pool := &SyncPool{
		make([]sync.Pool, n),
		make([]int, n),
		minSize, maxSize,
	}
	n = 0
	for chunkSize := minSize; chunkSize <= maxSize; chunkSize *= factor {
		pool.classesSize[n] = chunkSize
		pool.classes[n].New = func(size int) func() interface{} {
			return func() interface{} {
				buf := make([]RawMem, size)
				return &buf
			}
		}(chunkSize)
		n++
	}
	return pool
}

// Alloc try alloc a []byte from internal slab class if no free chunk in slab class Alloc will make one.
func (pool *SyncPool) Alloc(size int) []RawMem {
	if size <= pool.maxSize {
		for i := 0; i < len(pool.classesSize); i++ {
			if pool.classesSize[i] >= size {
				mem := pool.classes[i].Get().(*[]RawMem)
				return (*mem)[:size]
			}
		}
	}
	return make([]RawMem, size)
}

// Free release a []byte that alloc from Pool.Alloc.
func (pool *SyncPool) Free(mem []RawMem) {
	if size := cap(mem); size <= pool.maxSize {
		for i := 0; i < len(pool.classesSize); i++ {
			if pool.classesSize[i] >= size {
				pool.classes[i].Put(&mem)
				return
			}
		}
	}
}

func BenchmarkPool(b *testing.B) {
	pool := NewSyncPool(MinSize, MaxSize, 2)
	b.ResetTimer()
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			size := rand.Intn(1024 * 100)

			ret := &SensorData1{}
			ret.GsPoints = pool.Alloc(size)
			if len(ret.GsPoints) != size {
				b.Fatal("not equal")
			}

			for i := 0; i < size; i++ {
				ret.GsPoints[i] = RawMem{int64(size), int64(size), int64(size), int64(size)}
			}

			for i := 0; i < size; i++ {
				m := RawMem{int64(size), int64(size), int64(size), int64(size)}
				if ret.GsPoints[i] != m {
					b.Fatal("not equal m")
				}
			}

			pool.Free(ret.GsPoints)
		}
	})
}

func BenchmarkMake(b *testing.B) {
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			size := rand.Intn(1024 * 100)

			ret := &SensorData1{}
			ret.GsPoints = make([]RawMem, size)
			if len(ret.GsPoints) != size {
				b.Fatal("not equal")
			}

			for i := 0; i < size; i++ {
				ret.GsPoints[i] = RawMem{int64(size), int64(size), int64(size), int64(size)}
			}

			for i := 0; i < size; i++ {
				m := RawMem{int64(size), int64(size), int64(size), int64(size)}
				if ret.GsPoints[i] != m {
					b.Fatal("not equal m")
				}
			}
		}
	})
}