Remove ring buffer

Author: Cuda-Chen

virtio-snd.c

@@ -271,29 +271,11 @@ typedef struct {
     uint8_t positions[VIRTIO_SND_CHMAP_MAX_SIZE];
 } virtio_snd_chmap_info_t;
 
-/* PCM frame ring buffer */
-/* Adapted from DPDK ring buffer. */
-/* https://github.com/scylladb/dpdk/blob/master/lib/librte_ring/rte_ring.h#L147
- */
-#define VSND_RING_SZ_MASK 0x0FFFFFFFULL /* ring size mask */
 typedef struct {
-    void *buffer;
     pthread_cond_t readable, writable;
     int buf_ev_notity;
     pthread_mutex_t lock;
-    struct prod {
-        volatile uint32_t head; /* producer head */
-        volatile uint32_t tail; /* producer tail */
-        uint32_t size;          /* Size of ring. */
-        uint32_t mask;          /* Mask (size of buffer - 1) of ring.*/
-    } prod;
-    struct cons {
-        volatile uint32_t head; /* consumer head */
-        volatile uint32_t tail; /* consumer tail */
-        uint32_t size;          /* Size of ring. */
-        uint32_t mask;          /* Mask (size of buffer - 1) of ring.*/
-    } cons;
-} virtio_snd_ring_buffer_t;
+} virtio_snd_queue_lock_t;
 
 typedef struct {
     int32_t guest_playing;
@@ -318,13 +300,13 @@ typedef struct {
     struct CNFADriver *audio_host;
     bool is_guest_playing;
 
-    // PCM frame ring buffer
-    virtio_snd_ring_buffer_t ring;
+    // PCM frame queue lock
+    virtio_snd_queue_lock_t lock;
     // PCM frame doubly-ended queue
     vsnd_buf_queue_node_t buf;
     struct list_head buf_queue_head;
-    // PCM frame immediate buffer;
-    void *immediate;
+    // PCM frame intermediate buffer;
+    void *intermediate;
 
     // playback control
     vsnd_stream_sel_t v;
@@ -554,23 +536,14 @@ static void virtio_snd_read_pcm_prepare(const virtio_snd_pcm_hdr_t *query,
         CNFAInit(NULL, "semu-virtio-snd", virtio_snd_cb, rate, 0, channels, 0,
                  cnfa_period_frames, NULL, NULL, &props->v);
     uint32_t sz = props->pp.buffer_bytes;
-    props->ring.buffer = (void *) malloc(sizeof(*props->ring.buffer) * sz);
-    props->ring.prod.head = 0;
-    props->ring.prod.tail = 0;
-    props->ring.cons.head = 0;
-    props->ring.cons.tail = 0;
-    props->ring.prod.size = sz;
-    props->ring.cons.size = sz;
-    props->ring.prod.mask = sz - 1;
-    props->ring.cons.mask = sz - 1;
-    pthread_mutex_init(&props->ring.lock, NULL);
-    pthread_cond_init(&props->ring.readable, NULL);
-    pthread_cond_init(&props->ring.writable, NULL);
+    pthread_mutex_init(&props->lock.lock, NULL);
+    pthread_cond_init(&props->lock.readable, NULL);
+    pthread_cond_init(&props->lock.writable, NULL);
     pthread_mutex_init(&props->v.ctrl_mutex, NULL);
     pthread_cond_init(&props->v.ctrl_cond, NULL);
     INIT_LIST_HEAD(&props->buf_queue_head);
-    props->immediate =
-        (void *) malloc(sizeof(*props->immediate) * cnfa_period_bytes);
+    props->intermediate =
+        (void *) malloc(sizeof(*props->intermediate) * cnfa_period_bytes);
 #if WRITEOUT
     outfile = fopen("out_deque.bin", "wb");
 #endif
@@ -651,11 +624,10 @@ static void virtio_snd_read_pcm_release(const virtio_snd_pcm_hdr_t *query,
     fclose(outfile);
 #endif
     /* Tear down the PCM ring buffer. */
-    free(props->ring.buffer);
-    free(props->immediate);
-    pthread_mutex_destroy(&props->ring.lock);
-    pthread_cond_destroy(&props->ring.readable);
-    pthread_cond_destroy(&props->ring.writable);
+    free(props->intermediate);
+    pthread_mutex_destroy(&props->lock.lock);
+    pthread_cond_destroy(&props->lock.readable);
+    pthread_cond_destroy(&props->lock.writable);
     /* Tear down the PCM buffer queue */
     vsnd_buf_queue_node_t *tmp = NULL;
     vsnd_buf_queue_node_t *node;
@@ -684,54 +656,15 @@ static void __virtio_snd_frame_dequeue(short *out,
                                        uint32_t stream_id)
 {
     virtio_snd_prop_t *props = &vsnd_props[stream_id];
-    uint32_t cons_head, prod_tail;
-    uint32_t cons_next, entries;
-    uint32_t mask = props->ring.cons.mask;
 
-    pthread_mutex_lock(&props->ring.lock);
-    while (props->ring.buf_ev_notity < 1) {
+    pthread_mutex_lock(&props->lock.lock);
+    while (props->lock.buf_ev_notity < 1) {
         fprintf(stderr, "---wait in deque---\n");
-        pthread_cond_wait(&props->ring.readable, &props->ring.lock);
+        pthread_cond_wait(&props->lock.readable, &props->lock.lock);
     }
 
-    cons_head = props->ring.cons.head;
-    prod_tail = props->ring.prod.tail;
-    /* The subtraction is done between two unsigned 32bits value
-     * (the result is always modulo 32 bits even if we have
-     * cons_head > prod_tail). So 'entries' is always between 0
-     * and size(ring)-1. */
-    entries = prod_tail - cons_head;
-
-    if (n > entries)
-        fprintf(stderr,
-                "consumer payload length %" PRIu32
-                " larger than entries %" PRIu32 "\n",
-                n, entries);
-
-    cons_next = cons_head + n;
-    props->ring.cons.head = cons_next;
-
-    /* Copy the frame to output stream */
-    uint32_t size = props->ring.cons.size;
-    uint32_t idx = cons_head % size;
-    fprintf(stderr,
-            "cons_head %" PRIu32 " cons_next %" PRIu32 " prod_tail %" PRIu32
-            " mask %" PRIu32 " idx %" PRIu32 "\n",
-            cons_head, cons_next, prod_tail, mask, idx);
-    /*if (idx + n < size) {
-        memcpy(out, props->ring.buffer + idx, n);
-    } else {
-        memcpy(out, props->ring.buffer + idx, size - idx);
-        memcpy(out + (size - idx), props->ring.buffer, n - (size - idx));
-        fprintf(stderr, "=== start %" PRIu32 " end %" PRIu32 "\n", size - idx,
-                n - (size - idx));
-    }*/
-    VSND_COMPILER_BARRIER;
-
-    props->ring.cons.tail = cons_next;
-
     uint32_t written_bytes = 0;
-    memset(props->immediate, 0, sizeof(*props->immediate) * n);
+    memset(props->intermediate, 0, sizeof(*props->intermediate) * n);
     while (!list_empty(&props->buf_queue_head) && written_bytes < n) {
         vsnd_buf_queue_node_t *node =
             list_first_entry(&props->buf_queue_head, vsnd_buf_queue_node_t, q);
@@ -747,7 +680,8 @@ static void __virtio_snd_frame_dequeue(short *out,
                 left, actual, len, written_bytes, node->pos, node->len,
                 node->addr);
 
-        memcpy(props->immediate + written_bytes, node->addr + node->pos, len);
+        memcpy(props->intermediate + written_bytes, node->addr + node->pos,
+               len);
 
 #if WRITEOUT
         fwrite(node->addr + node->pos, sizeof(void), len, outfile);
@@ -762,11 +696,11 @@ static void __virtio_snd_frame_dequeue(short *out,
     }
     fprintf(stderr, "*** written %" PRIu32 " out n %" PRIu32 "\n",
             written_bytes, n);
-    memcpy(out, props->immediate, written_bytes);
+    memcpy(out, props->intermediate, written_bytes);
 
-    props->ring.buf_ev_notity--;
-    pthread_cond_signal(&props->ring.writable);
-    pthread_mutex_unlock(&props->ring.lock);
+    props->lock.buf_ev_notity--;
+    pthread_cond_signal(&props->lock.writable);
+    pthread_mutex_unlock(&props->lock.lock);
 }
 static void virtio_snd_cb(struct CNFADriver *dev,
                           short *out,
@@ -894,72 +828,24 @@ static void __virtio_snd_frame_enqueue(void *payload,
                                        uint32_t n,
                                        uint32_t stream_id)
 {
-    uint32_t prod_head, cons_tail;
-    uint32_t prod_next, free_entries;
     virtio_snd_prop_t *props = &vsnd_props[stream_id];
-    uint32_t mask = props->ring.prod.mask;
 
-    pthread_mutex_lock(&props->ring.lock);
-    while (props->ring.buf_ev_notity > 0) {
+    pthread_mutex_lock(&props->lock.lock);
+    while (props->lock.buf_ev_notity > 0) {
         fprintf(stderr, "---wait for enque---\n");
-        pthread_cond_wait(&props->ring.writable, &props->ring.lock);
+        pthread_cond_wait(&props->lock.writable, &props->lock.lock);
     }
 
-    prod_head = props->ring.prod.head;
-    cons_tail = props->ring.cons.tail;
-    /* The subtraction is done between two unsigned 32bits value
-     * (the result is always modulo 32 bits even if we have
-     * prod_head > cons_tail). So 'free_entries' is always between 0
-     * and size(ring)-1. */
-    free_entries = mask + cons_tail - prod_head;
-    /*fprintf(stderr,
-            "mask %" PRIu32 " cons_tail %" PRIu32 " prod_head %" PRIu32 "\n",
-            mask, cons_tail, prod_head);*/
-
-    /* Move prod_head. */
-    if (n > free_entries)
-        fprintf(stderr,
-                "producer payload length %" PRIu32
-                " larger than free_entries %" PRIu32 "\n",
-                n, free_entries);
-    prod_next = prod_head + n;
-    props->ring.prod.head = prod_next;
-
-    /* Write payload to ring buffer. */
-    uint32_t size = props->ring.prod.size;
-    uint32_t idx = prod_head % size;
-    /*fprintf(stderr,
-            "prod_head %" PRIu32 " prod_next %" PRIu32 " mask %" PRIu32
-            " idx %" PRIu32 "\n",
-            prod_head, prod_next, mask, idx);*/
-    if (idx + n < size) {
-        memcpy(props->ring.buffer + idx, payload, n);
-    } else {
-        memcpy(props->ring.buffer + idx, payload, size - idx);
-        memcpy(props->ring.buffer, payload, n - (size - idx));
-    }
-    VSND_COMPILER_BARRIER;
-
-    /* Update prod_tail */
-    props->ring.prod.tail = prod_next;
-
     /* Add to queue */
+    /* TODO: add description of the speciality of Linux Kernel VirtIO sound
+     * driver */
     vsnd_buf_queue_node_t *node = malloc(sizeof(*node));
     node->addr = payload;
     node->len = n;
     node->pos = 0;
     list_push(&node->q, &props->buf_queue_head);
 
-    /*uint32_t period_bytes = props->pp.period_bytes;
-    if (prod_next - cons_tail >= period_bytes) {
-        fprintf(stderr,
-                "buffer ready for %" PRIu32 " cons_tail %" PRIu32
-                " prod_next %" PRIu32 "\n",
-                prod_next - cons_tail, cons_tail, prod_next);
-        props->ring.buf_ev_notity++;
-        pthread_cond_signal(&props->ring.readable);
-    }*/
-    pthread_mutex_unlock(&props->ring.lock);
+    pthread_mutex_unlock(&props->lock.lock);
 }
 
 typedef struct {
@@ -1036,8 +922,8 @@ static int virtio_snd_tx_desc_handler(virtio_snd_state_t *vsnd,
     }
 
     virtio_snd_prop_t *props = &vsnd_props[stream_id];
-    props->ring.buf_ev_notity++;
-    pthread_cond_signal(&props->ring.readable);
+    props->lock.buf_ev_notity++;
+    pthread_cond_signal(&props->lock.readable);
 
     /* Tear down the descriptor list and free space. */
     virtq_desc_queue_node_t *tmp = NULL;