update queue for max performance

2024-11-11 20:33:34 +01:00
parent 3eaa42b615
commit cd1fb91892
7 changed files with 272 additions and 171 deletions
--- a/cart-packet-queue.go
+++ b/cart-packet-queue.go
@@ -1,102 +1,186 @@
 package main

 import (
-	"fmt"
 	"io"
 	"log"
 	"net"
 	"sync"
-	"time"
 )

-type CartPacketWithData struct {
-	MessageType uint32
-	Id          CartId
-	Added       time.Time
-	Consumed    bool
-	Data        []byte
-}
-
 type CartPacketQueue struct {
-	mu      sync.RWMutex
-	Packets []CartPacketWithData
-	//connection net.Conn
+	mu               sync.RWMutex
+	expectedPackages map[uint32]*CartListener
 }

-const cartCap = 150
+type CartListener map[CartId]chan []byte

 func NewCartPacketQueue(connection net.Conn) *CartPacketQueue {

 	queue := &CartPacketQueue{
-		Packets: make([]CartPacketWithData, 0, cartCap),
-		//connection: connection,
+		expectedPackages: make(map[uint32]*CartListener),
 	}
-	go func() {
-		defer connection.Close()
-		var packet CartPacket
-		for {
-			err := ReadCartPacket(connection, &packet)
-			if err != nil {
-				if err == io.EOF {
-					return
-				}
-				log.Printf("Error receiving packet: %v\n", err)
-				//return
-			}
-
-			data, err := GetPacketData(connection, packet.DataLength)
-			if err != nil {
-				log.Printf("Error receiving packet data: %v\n", err)
-				return
-			}
-			go queue.HandleData(packet.MessageType, packet.Id, data)
-		}
-	}()
+	go queue.HandleConnection(connection)
 	return queue
 }

-func (p *CartPacketQueue) HandleData(t uint32, id CartId, data []byte) {
-	ts := time.Now()
-	l := make([]CartPacketWithData, 0, cartCap)
-	p.mu.RLock()
-	breakAt := ts.Add(-time.Millisecond * 250)
-	for _, packet := range p.Packets {
-		if !packet.Consumed && packet.Added.After(breakAt) {
-			l = append(l, packet)
-			if len(l) >= cartCap {
-				break
-			}
-		}
-	}
-	p.mu.RUnlock()
-	p.mu.Lock()
-	p.Packets = append([]CartPacketWithData{
-		{
-			MessageType: t,
-			Id:          id,
-			Added:       ts,
-			Data:        data,
-		},
-	}, l...)
-	p.mu.Unlock()
-}
-
-func (p *CartPacketQueue) Expect(messageType uint32, id CartId, timeToWait time.Duration) (*CartPacketWithData, error) {
-	start := time.Now().Add(-time.Millisecond)
+func (p *CartPacketQueue) HandleConnection(connection net.Conn) error {

+	defer connection.Close()
+	var packet CartPacket
 	for {
-		if time.Since(start) > timeToWait {
-			return nil, fmt.Errorf("timeout waiting for message type %d", messageType)
-		}
-		p.mu.RLock()
-		for _, packet := range p.Packets {
-			if !packet.Consumed && packet.MessageType == messageType && packet.Id == id && packet.Added.After(start) {
-				packet.Consumed = true
-				p.mu.RUnlock()
-				return &packet, nil
+		err := ReadCartPacket(connection, &packet)
+		if err != nil {
+			if err == io.EOF {
+				return nil
 			}
+			log.Printf("Error receiving packet: %v\n", err)
+			return err
 		}
-		p.mu.RUnlock()
-		time.Sleep(time.Millisecond * 2)
+		data, err := GetPacketData(connection, packet.DataLength)
+		if err != nil {
+			log.Printf("Error receiving packet data: %v\n", err)
+			return err
+		}
+		go p.HandleData(packet.MessageType, packet.Id, data)
 	}
 }
+
+func (p *CartPacketQueue) HandleData(t uint32, id CartId, data []byte) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	l, ok := p.expectedPackages[t]
+	if ok {
+		ch, ok := (*l)[id]
+		if ok {
+			ch <- data
+			close(ch)
+			delete(*l, id)
+		}
+	}
+	data = nil
+}
+
+func (p *CartPacketQueue) Expect(messageType uint32, id CartId) <-chan []byte {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	l, ok := p.expectedPackages[messageType]
+	if ok {
+		if ch, idOk := (*l)[id]; idOk {
+			return ch
+		}
+		ch := make(chan []byte)
+		(*l)[id] = ch
+		return ch
+	}
+
+	ch := make(chan []byte)
+	p.expectedPackages[messageType] = &CartListener{
+		id: ch,
+	}
+
+	return ch
+
+}
+
+// package main
+
+// import (
+// 	"fmt"
+// 	"io"
+// 	"log"
+// 	"net"
+// 	"sync"
+// 	"time"
+// )
+
+// type CartPacketWithData struct {
+// 	MessageType uint32
+// 	Id          CartId
+// 	Added       time.Time
+// 	Consumed    bool
+// 	Data        []byte
+// }
+
+// type CartPacketQueue struct {
+// 	mu      sync.RWMutex
+// 	Packets []CartPacketWithData
+// 	//connection net.Conn
+// }
+
+// const cartCap = 150
+
+// func NewCartPacketQueue(connection net.Conn) *CartPacketQueue {
+
+// 	queue := &CartPacketQueue{
+// 		Packets: make([]CartPacketWithData, 0, cartCap),
+// 		//connection: connection,
+// 	}
+// 	go func() {
+// 		defer connection.Close()
+// 		var packet CartPacket
+// 		for {
+// 			err := ReadCartPacket(connection, &packet)
+// 			if err != nil {
+// 				if err == io.EOF {
+// 					return
+// 				}
+// 				log.Printf("Error receiving packet: %v\n", err)
+// 				//return
+// 			}
+
+// 			data, err := GetPacketData(connection, packet.DataLength)
+// 			if err != nil {
+// 				log.Printf("Error receiving packet data: %v\n", err)
+// 				return
+// 			}
+// 			go queue.HandleData(packet.MessageType, packet.Id, data)
+// 		}
+// 	}()
+// 	return queue
+// }
+
+// func (p *CartPacketQueue) HandleData(t uint32, id CartId, data []byte) {
+// 	ts := time.Now()
+// 	l := make([]CartPacketWithData, 0, cartCap)
+// 	p.mu.RLock()
+// 	breakAt := ts.Add(-time.Millisecond * 250)
+// 	for _, packet := range p.Packets {
+// 		if !packet.Consumed && packet.Added.After(breakAt) {
+// 			l = append(l, packet)
+// 			if len(l) >= cartCap {
+// 				break
+// 			}
+// 		}
+// 	}
+// 	p.mu.RUnlock()
+// 	p.mu.Lock()
+// 	p.Packets = append([]CartPacketWithData{
+// 		{
+// 			MessageType: t,
+// 			Id:          id,
+// 			Added:       ts,
+// 			Data:        data,
+// 		},
+// 	}, l...)
+// 	p.mu.Unlock()
+// }
+
+// func (p *CartPacketQueue) Expect(messageType uint32, id CartId, timeToWait time.Duration) (*CartPacketWithData, error) {
+// 	start := time.Now().Add(-time.Millisecond)
+
+// 	for {
+// 		if time.Since(start) > timeToWait {
+// 			return nil, fmt.Errorf("timeout waiting for message type %d", messageType)
+// 		}
+// 		p.mu.RLock()
+// 		for _, packet := range p.Packets {
+// 			if !packet.Consumed && packet.MessageType == messageType && packet.Id == id && packet.Added.After(start) {
+// 				packet.Consumed = true
+// 				p.mu.RUnlock()
+// 				return &packet, nil
+// 			}
+// 		}
+// 		p.mu.RUnlock()
+// 		time.Sleep(time.Millisecond * 2)
+// 	}
+// }