Add lock free queue source code

Author: galt-tr

README.md

@@ -380,12 +380,12 @@ make bench
 
 ### Benchmark Results
 
-| Benchmark                           | Iterations | ns/op | B/op | allocs/op |
-|-------------------------------------|------------|------:|-----:|----------:|
-| [Greet](template_benchmark_test.go) | 21,179,739 | 56.59 |   40 |         2 |
+| Benchmark                                        | Iterations | ns/op | B/op | allocs/op |
+|--------------------------------------------------|------------|------:|-----:|----------:|
+| [LockFreeQ](lock_free_queue_benchmark_test.go)   | 15076060   | 73.92 |   16 |         1 |
 
 > These benchmarks reflect fast, allocation-free lookups for most retrieval functions, ensuring optimal performance in production environments.
-> Performance benchmarks for the core functions in this library, executed on an Apple M1 Max (ARM64).
+> Performance benchmarks for the core functions in this library, executed on an 13th Gen Intel i7-1360P (AMD64).
 
 <br/>
 

lock_free_queue.go

@@ -0,0 +1,62 @@
+// Package lockfreequeue provides operations for a FIFO structure with
+// operations to enqueue and dequeue generic values.
+package lockfreequeue
+
+import (
+	"sync/atomic"
+)
+
+type node[T any] struct {
+	value T
+	next  atomic.Pointer[node[T]]
+}
+
+// LockFreeQ represents a FIFO structure with operations to enqueue
+// and dequeue generic values.
+// This implementation is concurrent safe for queueing, but not for dequeueing.
+// Reference: https://www.cs.rochester.edu/research/synchronization/pseudocode/queues.html
+type LockFreeQ[T any] struct {
+	head *node[T]
+	tail atomic.Pointer[node[T]]
+}
+
+// NewLockFreeQ creates and initializes a LockFreeQueue
+func NewLockFreeQ[T any]() *LockFreeQ[T] {
+	return &LockFreeQ[T]{
+		head: &node[T]{},
+		tail: atomic.Pointer[node[T]]{},
+	}
+}
+
+// Enqueue adds a series of Request to the queue
+// Enqueue is thread safe, it uses atomic operations to add to the queue
+func (q *LockFreeQ[T]) Enqueue(v T) {
+	node := &node[T]{value: v}
+	prev := q.tail.Swap(node)
+
+	if prev == nil {
+		q.head.next.Store(node)
+		return
+	}
+
+	prev.next.Store(node)
+}
+
+// Dequeue removes a Request from the queue
+// Dequeue is not thread safe, it should only be called from a single thread !!!
+func (q *LockFreeQ[T]) Dequeue() *T {
+	next := q.head.next.Load()
+
+	if next == nil {
+		return nil
+	}
+
+	q.head = next
+
+	return &next.value
+}
+
+// IsEmpty determines if the queue is empty
+func (q *LockFreeQ[T]) IsEmpty() bool {
+	return q.head.next.Load() == nil
+}

lock_free_queue_benchmark_test.go

@@ -1 +1,19 @@
 package lockfreequeue
+
+import (
+	"testing"
+)
+
+func BenchmarkLockFreeQueue(b *testing.B) {
+	q := NewLockFreeQ[int]()
+
+	for i := 0; i < b.N; i++ {
+		q.Enqueue(i)
+	}
+
+	for i := 0; i < b.N; i++ {
+		if val := q.Dequeue(); val == nil {
+			b.Errorf("Expected a value, got nil at iteration %d", i)
+		}
+	}
+}

lock_free_queue_test.go

@@ -0,0 +1,74 @@
+package lockfreequeue
+
+import (
+	"sync"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestEnqueueDequeue(t *testing.T) {
+	q := NewLockFreeQ[int]() // Assuming your LockFreeQ works with int for this example
+
+	// Enqueue elements
+	q.Enqueue(1)
+	q.Enqueue(2)
+
+	// Dequeue and check elements
+	if val := q.Dequeue(); val == nil || *val != 1 {
+		t.Errorf("Expected 1, got %v", val)
+	}
+
+	if val := q.Dequeue(); val == nil || *val != 2 {
+		t.Errorf("Expected 2, got %v", val)
+	}
+
+	// Check if queue is empty
+	assert.True(t, q.IsEmpty(), "Expected queue to be empty after dequeuing all elements")
+	assert.Nil(t, q.Dequeue())
+}
+
+func TestConcurrentEnqueue(t *testing.T) {
+	q := NewLockFreeQ[int]()
+
+	var wg sync.WaitGroup
+
+	numWorkers := 100 // Number of concurrent goroutines
+	numEnqueues := 10 // Number of enqueues per goroutine
+
+	for i := 0; i < numWorkers; i++ {
+		wg.Add(1)
+
+		go func(workerID int) {
+			defer wg.Done()
+
+			for j := 0; j < numEnqueues; j++ {
+				q.Enqueue(workerID*numEnqueues + j)
+			}
+		}(i)
+	}
+
+	wg.Wait()
+
+	// Assuming your dequeue is not concurrently safe, this part is tricky.
+	// We can't guarantee the order of elements, but we can check if all elements are present.
+	// This part of the test will need adjustment based on your dequeue method's thread safety.
+	seen := make(map[int]bool)
+
+	for i := 0; i < numWorkers*numEnqueues; i++ {
+		val := q.Dequeue()
+		if val == nil {
+			t.Fatalf("Expected a value, got nil at iteration %d", i)
+		}
+
+		if seen[*val] {
+			t.Errorf("Duplicate value detected: %v", *val)
+		}
+
+		seen[*val] = true
+	}
+
+	if !q.IsEmpty() {
+		t.Errorf("Expected queue to be empty after all dequeues")
+	}
+}