perf(scale): optimize scale read loop lock contention

internal/scale/scale.go

@@ -80,11 +80,22 @@ func GenerateSimulatedWeights() []float64 {
 	return weights
 }
 
+// Port interface to abstract serial port dependency for testing
+type Port interface {
+	io.ReadWriteCloser
+	SetReadTimeout(time.Duration) error
+}
+
+// variable to allow mocking serial.Open
+var serialOpen = func(name string, mode *serial.Mode) (Port, error) {
+	return serial.Open(name, mode)
+}
+
 // Reader manages serial port communication with the scale
 type Reader struct {
 	config    *config.Config
 	broadcast chan<- string
-	port      serial.Port
+	port      Port
 	mu        sync.Mutex
 	stopCh    chan struct{}
 }
@@ -198,8 +209,16 @@ func (r *Reader) readCycle(ctx context.Context) {
 			break
 		}
 
+		r.mu.Unlock()
+
 		time.Sleep(500 * time.Millisecond)
 
+		r.mu.Lock()
+		if r.port == nil {
+			r.mu.Unlock()
+			break
+		}
+
 		// Read response
 		buf := make([]byte, 20)
 		n, err := r.port.Read(buf)
@@ -256,7 +275,7 @@ func (r *Reader) connect(puerto string) error {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 
-	port, err := serial.Open(puerto, mode)
+	port, err := serialOpen(puerto, mode)
 	if err != nil {
 		return err
 	}

internal/scale/scale_perf_test.go

@@ -0,0 +1,96 @@
+package scale
+
+import (
+	"context"
+	"io"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/adcondev/scale-daemon/internal/config"
+	"go.bug.st/serial"
+)
+
+// MockPort implements Port interface for testing
+type MockPort struct {
+	mu     sync.Mutex
+	closed bool
+}
+
+func (m *MockPort) Read(p []byte) (n int, err error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.closed {
+		return 0, io.EOF
+	}
+	// Simulate some data
+	return copy(p, []byte("10.50")), nil
+}
+
+func (m *MockPort) Write(p []byte) (n int, err error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.closed {
+		return 0, io.ErrClosedPipe
+	}
+	return len(p), nil
+}
+
+func (m *MockPort) Close() error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.closed = true
+	return nil
+}
+
+func (m *MockPort) SetReadTimeout(t time.Duration) error {
+	return nil
+}
+
+func TestLockContention(t *testing.T) {
+	// Setup config
+	cfg := config.New(config.Environment{
+		DefaultPort: "COM_TEST",
+		DefaultMode: false, // Ensure we use the real connection path
+	})
+
+	// Override serialOpen for testing
+	origSerialOpen := serialOpen
+	defer func() { serialOpen = origSerialOpen }()
+
+	mockPort := &MockPort{}
+	serialOpen = func(name string, mode *serial.Mode) (Port, error) {
+		return mockPort, nil
+	}
+
+	broadcast := make(chan string, 10)
+	r := NewReader(cfg, broadcast)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	// Start reader in background
+	go r.Start(ctx)
+
+	// Wait for the reader to enter the read loop and acquire the lock.
+	// We want to catch it during the 500ms sleep.
+	// Since we don't know exactly when it starts sleeping, we can try multiple times or just wait a bit.
+	// Connect happens fast (mock). Write happens fast (mock).
+	// So sleep starts almost immediately.
+	time.Sleep(50 * time.Millisecond)
+
+	// Now try to close port. This acquires the lock.
+	start := time.Now()
+
+	// r.ClosePort() will block until the lock is released.
+	// If the lock is held during sleep, this will take ~450ms (500ms - 50ms).
+	r.ClosePort()
+
+	duration := time.Since(start)
+
+	t.Logf("ClosePort duration: %v", duration)
+
+	if duration > 100*time.Millisecond {
+		t.Errorf("Lock contention detected: ClosePort took %v, expected < 100ms. The lock is likely held during sleep.", duration)
+	}
+}