From ab46884ef8c9d7bedaf82ebd04f8285e29885e7d Mon Sep 17 00:00:00 2001
From: hgn <hgodden00@gmail.com>
Date: Thu, 10 Apr 2025 21:15:48 +0100
Subject: [PATCH] removed reallocation things from queues because it was stupid
 and sucked

---
 vg_async2.c    | 44 ++++++++------------------------------------
 vg_async2.h    |  2 +-
 vg_mem_queue.c | 45 ---------------------------------------------
 vg_mem_queue.h |  3 ---
 vg_msg.c       |  4 +---
 5 files changed, 10 insertions(+), 88 deletions(-)

diff --git a/vg_async2.c b/vg_async2.c
index 55d45fe..76bb850 100644
--- a/vg_async2.c
+++ b/vg_async2.c
@@ -11,6 +11,11 @@ bool vg_init_async_queue( vg_async_queue *queue )
    if( sem_init( &queue->blocking_memory_signal, 0, 0 ) )
       goto e2;
 
+   queue->queue.buffer = malloc( queue->buffer_size );
+   queue->queue.size = queue->buffer_size;
+   if( !queue->queue.buffer ) 
+      goto e2;
+
    return 1;
 e2: pthread_mutex_destroy( &queue->data_lock );
 e1: pthread_mutex_destroy( &queue->lock );
@@ -26,48 +31,13 @@ void vg_free_async_queue( vg_async_queue *queue )
 
 vg_async_task *vg_allocate_async_task( vg_async_queue *queue, u32 bytes, bool blocking )
 {
-   if( queue->upper_memory_limit )
-      VG_ASSERT( bytes <= queue->upper_memory_limit );
-
+   VG_ASSERT( bytes <= queue->queue.size );
    u32 total_size = sizeof(vg_async_task) + bytes;
    pthread_mutex_lock( &queue->data_lock );
    pthread_mutex_lock( &queue->lock );
    vg_queue *ring = &queue->queue;
    vg_async_task *task = vg_queue_alloc( ring, total_size, NULL );
 
-   if( !task )
-   {
-      bool reallocate = 1;
-      if( queue->upper_memory_limit )
-      {
-         if( ring->size >= queue->upper_memory_limit )
-            reallocate = 0;
-      }
-
-      if( reallocate )
-      {
-         u32 min_size  = vg_align8( total_size ) + sizeof(vg_queue_item) + vg_queue_usage( ring ),
-             grow_size = ring->size * 2,
-             max_size  = queue->upper_memory_limit? queue->upper_memory_limit: 0xffffffff;
-
-         u32 new_size = min_size;
-         if( grow_size > new_size )
-            new_size = grow_size;
-
-         if( new_size > max_size )
-            new_size = max_size;
-
-         vg_queue new_q = { .buffer = malloc( new_size ), .size = new_size };
-         if( new_q.buffer )
-         {
-            vg_queue_copy_upgrade( ring, &new_q );
-            free( ring->buffer );
-            *ring = new_q;
-            task = vg_queue_alloc( ring, total_size, NULL );
-         }
-      }
-   }
-
    if( !task )
    {
       if( blocking )
@@ -121,7 +91,9 @@ bool vg_async_consume( vg_async_queue *queue, u32 limit )
       {
          if( task->dispatched )
          {
+            pthread_mutex_unlock( &queue->lock );
             task->handler( task );
+            pthread_mutex_lock( &queue->lock );
             vg_queue_pop( &queue->queue );
          }
          else 
diff --git a/vg_async2.h b/vg_async2.h
index 2e8a98a..1852e20 100644
--- a/vg_async2.h
+++ b/vg_async2.h
@@ -10,7 +10,7 @@ typedef struct vg_async_task vg_async_task;
 
 struct vg_async_queue
 {
-   u32 upper_memory_limit;
+   u32 buffer_size;
    u32 requested_bytes;
 
    sem_t blocking_memory_signal;
diff --git a/vg_mem_queue.c b/vg_mem_queue.c
index 4f10fb3..d7f15ad 100644
--- a/vg_mem_queue.c
+++ b/vg_mem_queue.c
@@ -16,51 +16,6 @@ void vg_queue_memcpy( vg_queue *q, void *dst, u32 start, u32 size )
       memcpy( dst, q->buffer + start, size );
 }
 
-/*
- * Copy q1 to q2, and reorganize the memory to correct for q2's new size
- */
-void vg_queue_copy_upgrade( vg_queue *q1, vg_queue *q2 )
-{
-   if( q1->allocation_count == 0 )
-   {
-      q2->head_offset = 0;
-      q2->tail_offset = 0;
-      q2->allocation_count = 0;
-      return;
-   }
-
-   vg_queue_item *head = q1->buffer + q1->head_offset;
-   u32 end = q1->head_offset + head->alloc_size,
-       start = q1->tail_offset;
-
-   q2->y0 = start;
-   q2->allocation_count = q1->allocation_count;
-   q2->tail_offset = 0;
-   if( start < end )
-   {
-      u32 r0 = end-start;
-      VG_ASSERT( q2->size >= r0 );
-      memcpy( q2->buffer, q1->buffer+start, r0 );
-      q2->head_offset = r0 - head->alloc_size;
-      q2->z0 = r0;
-   }
-   else
-   {
-      u32 r0 = q1->size - start;
-      VG_ASSERT( q2->size >= (r0+end) );
-      memcpy( q2->buffer, q1->buffer+start, r0 );
-      memcpy( q2->buffer + r0, q1->buffer, end );
-      q2->head_offset = r0 + end - head->alloc_size;
-      q2->z0 = r0;
-   }
-}
-
-u32 vg_queue_offset_upgrade( vg_queue *q, u32 offset )
-{
-   if( offset > q->y0 ) return offset - q->y0;
-   else                 return offset + q->z0;
-}
-
 void *vg_queue_data( vg_queue *q, u32 offset )
 {
    vg_queue_item *item = q->buffer + offset;
diff --git a/vg_mem_queue.h b/vg_mem_queue.h
index e1691f2..3af3de6 100644
--- a/vg_mem_queue.h
+++ b/vg_mem_queue.h
@@ -17,7 +17,6 @@ struct vg_queue
    u32 size;
    u32 head_offset, tail_offset;
    u32 allocation_count;
-   u32 y0, z0;
 };
 
 void *vg_queue_alloc( vg_queue *q, u32 size, u32 *out_offset );
@@ -30,8 +29,6 @@ u32 vg_queue_item_size( vg_queue *q, u32 item_id );
 bool vg_queue_next( vg_queue *q, u32 item_id, u32 *out_next );
 bool vg_queue_previous( vg_queue *q, u32 item_id, u32 *out_prev );
 void vg_queue_pop( vg_queue *q );
-void vg_queue_copy_upgrade( vg_queue *q1, vg_queue *q2 );
-u32 vg_queue_offset_upgrade( vg_queue *q, u32 offset );
 void vg_queue_memcpy( vg_queue *q, void *dst, u32 start, u32 size );
 
 u32 vg_queue_usage( vg_queue *q );
diff --git a/vg_msg.c b/vg_msg.c
index 7e1eee1..145c6c0 100644
--- a/vg_msg.c
+++ b/vg_msg.c
@@ -124,11 +124,9 @@ u8 vg_msg_count_bits( u32 count )
 }
 
 /* write a sized type */
-void vg_msg_wkvnum( vg_msg *msg, const char *key,
-                    u8 type, u8 count, void *data )
+void vg_msg_wkvnum( vg_msg *msg, const char *key, u8 type, u8 count, void *data )
 {
    u8 code = type | vg_msg_count_bits(count);
-
    vg_msg_wbuf( msg, &code, 1 );
    vg_msg_wstr( msg, key );
    vg_msg_wbuf( msg, data, vg_msg_cmd_bytecount(code) );
-- 
2.25.1