gitee.com/sy_183/go-common@v1.0.5-0.20231205030221-958cfe129b47/ipc/cgo/sem/queue/queue32.go

package queue

import (
	semPkg "gitee.com/sy_183/go-common/ipc/cgo/sem"
	"sync/atomic"
)

type Queue32 struct {
	cap  uint32
	head uint32
	tail uint32
}

func (q *Queue32) Init(cap uint32) {
	if (cap & (cap - 1)) != 0 {
		panic(ErrInvalidCap)
	}
	q.cap = cap
	q.head = 0
	q.tail = 0
}

func (q *Queue32) Len() uint32 {
	return atomic.LoadUint32(&q.tail) - atomic.LoadUint32(&q.head)
}

func (q *Queue32) Cap() uint32 {
	return q.cap
}

func wait(sem *semPkg.Sem) error {
	if sem != nil {
		return sem.Wait()
	}
	return nil
}

func post(sem *semPkg.Sem) error {
	if sem != nil {
		v, err := sem.GetValue()
		if err != nil {
			return err
		}
		if v == 0 {
			return sem.Post()
		}
	}
	return nil
}

type Queue32View struct {
	queue *Queue32
	start uint32
	end   uint32
}

func (v Queue32View) Len() uint32 {
	return v.end - v.start
}

func (v Queue32View) Slice(raw []byte) (prefix []byte, suffix []byte) {
	if len(raw) != int(v.queue.cap) {
		return nil, nil
	}
	mask := v.queue.cap - 1
	start, end := v.start&mask, v.end&mask
	if end >= start {
		return raw[start:end], nil
	} else {
		return raw[end:], raw[:start]
	}
}

const (
	PostModeCanAlloc = iota
	PostModeCanUse   = iota
)

func (v *Queue32View) Post(mode int, sem *semPkg.Sem) error {
	switch mode {
	case PostModeCanAlloc:
		atomic.StoreUint32(&v.queue.head, v.end)
		//if !atomic.CompareAndSwapUint32(&v.queue.head, v.start, v.end) {
		//	panic(ErrConcurrentUse)
		//}
		return post(sem)
	case PostModeCanUse:
		atomic.StoreUint32(&v.queue.tail, v.end)
		//if !atomic.CompareAndSwapUint32(&v.queue.tail, v.start, v.end) {
		//	panic(ErrConcurrentAlloc)
		//}
		return post(sem)
	}
	return nil
}

func (q *Queue32) view(start, end uint32) Queue32View {
	return Queue32View{
		queue: q,
		start: start,
		end:   end,
	}
}

func (q *Queue32) can(start, end, p uint32) bool {
	if end >= start {
		// |✕✕✕✕✕✕✕✕|✓✓✓✓✓✓✓✓✓✓✓✓✓✓✓✓|✕✕✕✕✕✕✕✕✕✕✕|
		//          ↑                ↑
		// 0      start             end         2^32
		return p > start && p <= end
	} else {
		//
		// |✓✓✓✓✓✓✓✓|✕✕✕✕✕✕✕✕✕✕✕✕✕✕✕✕|✓✓✓✓✓✓✓✓✓✓✓|
		//          ↑                ↑
		// 0       end             start        2^32
		return p > start || p <= end
	}
}

func (q *Queue32) want(start, end, p uint32) Queue32View {
	if end >= start {
		// |✕✕✕✕✕✕✕✕|✓✓✓✓✓✓✓✓✓✓✓✓✓✓✓✓|✕✕✕✕✕✕✕✕✕✕✕|
		//          ↑                ↑
		// 0      start             end         2^32
		if p < start || p > end {
			return q.view(start, end)
		}
	} else {
		//
		// |✓✓✓✓✓✓✓✓|✕✕✕✕✕✕✕✕✕✕✕✕✕✕✕✕|✓✓✓✓✓✓✓✓✓✓✓|
		//          ↑                ↑
		// 0       end             start        2^32
		if p < start && p > end {
			return q.view(start, end)
		}
	}
	return q.view(start, p)
}

func (q *Queue32) TryAlloc(size uint32) (view Queue32View, ok bool) {
	if size == 0 || size > q.cap {
		return
	}
	tail := atomic.LoadUint32(&q.tail)
	if p := tail + size; q.can(tail, atomic.LoadUint32(&q.head)+q.cap, p) {
		return q.view(tail, p), true
	} else {
		return
	}
}

func (q *Queue32) WantTryAlloc(size uint32) (view Queue32View, ok bool) {
	if size == 0 {
		return
	}
	if size > q.cap {
		size = q.cap
	}
	tail, max := atomic.LoadUint32(&q.tail), atomic.LoadUint32(&q.head)+q.cap
	if tail == max {
		return
	}
	return q.want(tail, max, tail+size), true
}

func (q *Queue32) Alloc(size uint32, sem *semPkg.Sem) (view Queue32View, err error) {
	if size == 0 || size > q.cap {
		return
	}
	tail := atomic.LoadUint32(&q.tail)
	p := tail + size
	for !q.can(tail, atomic.LoadUint32(&q.head)+q.cap, p) {
		if err = wait(sem); err != nil {
			return
		}
	}
	return q.view(tail, p), nil
}

func (q *Queue32) WantAlloc(size uint32, sem *semPkg.Sem) (view Queue32View, err error) {
	if size == 0 {
		return
	}
	if size > q.cap {
		size = q.cap
	}
	tail, max := atomic.LoadUint32(&q.tail), atomic.LoadUint32(&q.head)+q.cap
	for tail == max {
		if err = wait(sem); err != nil {
			return
		}
		max = atomic.LoadUint32(&q.head) + q.cap
	}
	return q.want(tail, max, tail+size), nil
}

func (q *Queue32) TryUse(size uint32) (view Queue32View, ok bool) {
	if size == 0 || size > q.cap {
		return
	}
	head := atomic.LoadUint32(&q.head)
	if p := head + size; q.can(head, atomic.LoadUint32(&q.tail), p) {
		return q.view(head, p), true
	} else {
		return
	}
}

func (q *Queue32) WantTryUse(size uint32) (view Queue32View, ok bool) {
	if size == 0 {
		return
	}
	if size > q.cap {
		size = q.cap
	}
	head, tail := atomic.LoadUint32(&q.head), atomic.LoadUint32(&q.tail)
	if head == tail {
		return
	}
	return q.want(head, tail, head+size), true
}

func (q *Queue32) Use(size uint32, sem *semPkg.Sem) (view Queue32View, err error) {
	if size == 0 || size > q.cap {
		return
	}
	head := atomic.LoadUint32(&q.head)
	p := head + size
	for !q.can(head, atomic.LoadUint32(&q.tail), p) {
		if err = wait(sem); err != nil {
			return
		}
	}
	return q.view(head, p), nil
}

func (q *Queue32) WantUse(size uint32, sem *semPkg.Sem) (view Queue32View, err error) {
	if size == 0 {
		return
	}
	if size > q.cap {
		size = q.cap
	}
	head, tail := atomic.LoadUint32(&q.head), atomic.LoadUint32(&q.tail)
	for head == tail {
		if err = wait(sem); err != nil {
			return
		}
		tail = atomic.LoadUint32(&q.tail)
	}
	return q.want(head, tail, head+size), nil
}