root/opal/mca/pmix/pmix4x/pmix/src/class/pmix_ring_buffer.c

DEFINITIONS

1. pmix_ring_buffer_construct
2. pmix_ring_buffer_destruct
3. pmix_ring_buffer_init
4. pmix_ring_buffer_push
5. pmix_ring_buffer_pop
6. pmix_ring_buffer_poke

   1 /* -*- Mode: C; c-basic-offset:4 ; -*- */
   2 /*
   3  * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
   4  *                         University Research and Technology
   5  *                         Corporation.  All rights reserved.
   6  * Copyright (c) 2004-2007 The University of Tennessee and The University
   7  *                         of Tennessee Research Foundation.  All rights
   8  *                         reserved.
   9  * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
  10  *                         University of Stuttgart.  All rights reserved.
  11  * Copyright (c) 2004-2005 The Regents of the University of California.
  12  *                         All rights reserved.
  13  * Copyright (c) 2010      Cisco Systems, Inc. All rights reserved.
  14  * Copyright (c) 2016      Intel, Inc. All rights reserved
  15  * $COPYRIGHT$
  16  *
  17  * Additional copyrights may follow
  18  *
  19  * $HEADER$
  20  */
  21 
  22 #include <src/include/pmix_config.h>
  23 
  24 #include <stdlib.h>
  25 #include <stdio.h>
  26 #include <assert.h>
  27 
  28 #include "pmix_common.h"
  29 #include "src/class/pmix_ring_buffer.h"
  30 #include "src/util/output.h"
  31 
  32 static void pmix_ring_buffer_construct(pmix_ring_buffer_t *);
  33 static void pmix_ring_buffer_destruct(pmix_ring_buffer_t *);
  34 
  35 PMIX_CLASS_INSTANCE(pmix_ring_buffer_t, pmix_object_t,
  36                     pmix_ring_buffer_construct,
  37                     pmix_ring_buffer_destruct);
  38 
  39 /*
  40  * pmix_ring_buffer constructor
  41  */
  42 static void pmix_ring_buffer_construct(pmix_ring_buffer_t *ring)
  43 {
  44     ring->head = 0;
  45     ring->tail = -1;
  46     ring->size = 0;
  47     ring->addr = NULL;
  48 }
  49 
  50 /*
  51  * pmix_ring_buffer destructor
  52  */
  53 static void pmix_ring_buffer_destruct(pmix_ring_buffer_t *ring)
  54 {
  55     if( NULL != ring->addr) {
  56         free(ring->addr);
  57         ring->addr = NULL;
  58     }
  59 
  60     ring->size = 0;
  61 }
  62 
  63 /**
  64  * initialize a ring object
  65  */
  66 int pmix_ring_buffer_init(pmix_ring_buffer_t* ring, int size)
  67 {
  68     /* check for errors */
  69     if (NULL == ring) {
  70         return PMIX_ERR_BAD_PARAM;
  71     }
  72 
  73     /* Allocate and set the ring to NULL */
  74     ring->addr = (char **)calloc(size * sizeof(char*), 1);
  75     if (NULL == ring->addr) { /* out of memory */
  76         return PMIX_ERR_OUT_OF_RESOURCE;
  77     }
  78     ring->size = size;
  79 
  80     return PMIX_SUCCESS;
  81 }
  82 
  83 void* pmix_ring_buffer_push(pmix_ring_buffer_t *ring, void *ptr)
  84 {
  85     char *p=NULL;
  86 
  87     if (NULL != ring->addr[ring->head]) {
  88         p = (char*)ring->addr[ring->head];
  89         if (ring->tail == ring->size - 1) {
  90             ring->tail = 0;
  91         } else {
  92             ring->tail = ring->head + 1;
  93         }
  94     }
  95     ring->addr[ring->head] = (char*)ptr;
  96     if (ring->tail < 0) {
  97         ring->tail = ring->head;
  98     }
  99     if (ring->head == ring->size - 1) {
 100         ring->head = 0;
 101     } else {
 102         ring->head++;
 103     }
 104     return (void*)p;
 105 }
 106 
 107 void* pmix_ring_buffer_pop(pmix_ring_buffer_t *ring)
 108 {
 109     char *p=NULL;
 110 
 111     if (-1 == ring->tail) {
 112         /* nothing has been put on the ring yet */
 113         p = NULL;
 114     } else {
 115         p = (char*)ring->addr[ring->tail];
 116         ring->addr[ring->tail] = NULL;
 117         if (ring->tail == ring->size-1) {
 118             ring->tail = 0;
 119         } else {
 120             ring->tail++;
 121         }
 122         /* see if the ring is empty */
 123         if (ring->tail == ring->head) {
 124             ring->tail = -1;
 125         }
 126     }
 127     return (void*)p;
 128 }
 129 
 130  void* pmix_ring_buffer_poke(pmix_ring_buffer_t *ring, int i)
 131  {
 132     char *p=NULL;
 133     int offset;
 134 
 135     if (ring->size <= i || -1 == ring->tail) {
 136         p = NULL;
 137     } else if (i < 0) {
 138         /* return the value at the head of the ring */
 139         if (ring->head == 0) {
 140             p = ring->addr[ring->size - 1];
 141         } else {
 142             p = ring->addr[ring->head - 1];
 143         }
 144     } else {
 145         /* calculate the offset of the tail in the ring */
 146         offset = ring->tail + i;
 147         /* correct for wrap-around */
 148         if (ring->size <= offset) {
 149             offset -= ring->size;
 150         }
 151         p = ring->addr[offset];
 152     }
 153     return (void*)p;
 154 }