Merge branch 'develop' into testing-view/docs

Author: maximka76667

.github/dependabot.yml

@@ -0,0 +1,12 @@
+version: 2
+updates:
+  - package-ecosystem: "npm"
+    directory: "/"
+    schedule:
+      interval: "daily"
+    target-branch: "develop" 
+  - package-ecosystem: "npm"
+    directory: "/"
+    schedule:
+      interval: "daily"
+    target-branch: "main" 

backend/pkg/transport/constructor.go

@@ -12,7 +12,7 @@ import (
 
 func NewTransport(baseLogger zerolog.Logger) *Transport {
 	transport := &Transport{
-		connectionsMx: &sync.Mutex{},
+		connectionsMx: &sync.RWMutex{},
 		connections:   make(map[abstraction.TransportTarget]net.Conn),
 		idToTarget:    make(map[abstraction.PacketId]abstraction.TransportTarget),
 		ipToTarget:    make(map[string]abstraction.TransportTarget),

backend/pkg/transport/packet/data/decoder.go

@@ -35,7 +35,7 @@ func (decoder *Decoder) Decode(id abstraction.PacketId, reader io.Reader) (abstr
 		return nil, ErrUnexpectedId{Id: id}
 	}
 
-	packet := NewPacket(id)
+	packet := GetPacket(id)
 	for _, value := range descriptor {
 		val, err := value.Decode(decoder.endianness, reader)
 		if err != nil {

backend/pkg/transport/packet/data/packet.go

@@ -1,6 +1,7 @@
 package data
 
 import (
+	"sync"
 	"time"
 
 	"github.com/HyperloopUPV-H8/h9-backend/pkg/abstraction"
@@ -27,6 +28,16 @@ func NewPacket(id abstraction.PacketId) *Packet {
 	}
 }
 
+var packetPool = sync.Pool{
+	New: func() any {
+		return &Packet{
+			values:  make(map[ValueName]Value),
+			enabled: make(map[ValueName]bool),
+		}
+	},
+}
+
+
 // NewPacketWithValues creates a new data packet with the given values
 func NewPacketWithValues(id abstraction.PacketId, values map[ValueName]Value, enabled map[ValueName]bool) *Packet {
 	return &Packet{
@@ -62,3 +73,35 @@ func (packet *Packet) SetTimestamp(timestamp time.Time) *Packet {
 	packet.timestamp = timestamp
 	return packet
 }
+
+func (packet *Packet) Reset() {
+	clear(packet.values)
+	clear(packet.enabled)
+	packet.id = 0
+	packet.timestamp = time.Time{}
+}
+
+func GetPacket(id abstraction.PacketId) *Packet {
+	p := packetPool.Get().(*Packet)
+	if p.values == nil {
+		p.values = make(map[ValueName]Value)
+	} else {
+		clear(p.values)
+	}
+	if p.enabled == nil {
+		p.enabled = make(map[ValueName]bool)
+	} else {
+		clear(p.enabled)
+	}
+	p.id = id
+	p.timestamp = time.Now()
+	return p
+}
+
+func ReleasePacket(p *Packet) {
+	if p == nil {
+		return
+	}
+	p.Reset()
+	packetPool.Put(p)
+}

backend/pkg/transport/presentation/encoder.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"encoding/binary"
 	"io"
+	"sync"
 
 	"github.com/HyperloopUPV-H8/h9-backend/pkg/abstraction"
 	"github.com/rs/zerolog"
@@ -17,7 +18,8 @@ type Encoder struct {
 	idToEncoder map[abstraction.PacketId]PacketEncoder
 	endianness  binary.ByteOrder
 
-	logger zerolog.Logger
+	logger  zerolog.Logger
+	bufPool sync.Pool
 }
 
 // TODO: improve constructor
@@ -28,6 +30,9 @@ func NewEncoder(endianness binary.ByteOrder, baseLogger zerolog.Logger) *Encoder
 		endianness:  endianness,
 
 		logger: baseLogger,
+		bufPool: sync.Pool{
+			New: func() any { return new(bytes.Buffer) },
+		},
 	}
 }
 
@@ -37,23 +42,41 @@ func (encoder *Encoder) SetPacketEncoder(id abstraction.PacketId, enc PacketEnco
 	encoder.logger.Trace().Uint16("id", uint16(id)).Type("encoder", enc).Msg("set encoder")
 }
 
-// Encode encodes the provided packet into a byte slice, returning any errors
-func (encoder *Encoder) Encode(packet abstraction.Packet) ([]byte, error) {
+// Encode encodes the provided packet into a pooled buffer. Callers must release
+// the buffer via ReleaseBuffer once they are done using the returned data.
+func (encoder *Encoder) Encode(packet abstraction.Packet) (*bytes.Buffer, error) {
 	enc, ok := encoder.idToEncoder[packet.Id()]
 	if !ok {
 		encoder.logger.Warn().Uint16("id", uint16(packet.Id())).Msg("no encoder set")
 		return nil, ErrUnexpectedId{Id: packet.Id()}
 	}
 
-	buffer := new(bytes.Buffer)
+	bufferAny := encoder.bufPool.Get()
+	buffer := bufferAny.(*bytes.Buffer)
+	buffer.Reset()
 
 	err := binary.Write(buffer, encoder.endianness, packet.Id())
 	if err != nil {
 		encoder.logger.Error().Stack().Err(err).Uint16("id", uint16(packet.Id())).Msg("buffering id")
-		return buffer.Bytes(), err
+		encoder.ReleaseBuffer(buffer)
+		return nil, err
 	}
 
 	encoder.logger.Debug().Uint16("id", uint16(packet.Id())).Type("encoder", enc).Msg("encoding")
 	err = enc.Encode(packet, buffer)
-	return buffer.Bytes(), err
+	if err != nil {
+		encoder.ReleaseBuffer(buffer)
+		return nil, err
+	}
+
+	return buffer, nil
+}
+
+// ReleaseBuffer returns a buffer obtained from Encode back to the pool.
+func (encoder *Encoder) ReleaseBuffer(buffer *bytes.Buffer) {
+	if buffer == nil {
+		return
+	}
+	buffer.Reset()
+	encoder.bufPool.Put(buffer)
 }

backend/pkg/transport/presentation/encoder_test.go

@@ -379,12 +379,13 @@ func TestEncoder(t *testing.T) {
 
 			output := make([]byte, 0, len(test.output))
 			for i := 0; i < len(test.input); i++ {
-				encoded, err := encoder.Encode(test.input[i])
+				buf, err := encoder.Encode(test.input[i])
 				if err != nil {
 					t.Fatalf("\nError encoding (%d) packet: %s\n", i+1, err)
 				}
 
-				output = append(output, encoded...)
+				output = append(output, buf.Bytes()...)
+				encoder.ReleaseBuffer(buf)
 
 			}