sdk/vector.h

   1 /*
   2  * vector.h
   3  *
   4  * Copyright (C) 2018 Aleksandar Andrejevic <theflash@sdf.lonestar.org>
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU Affero General Public License as
   8  * published by the Free Software Foundation, either version 3 of the
   9  * License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU Affero General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Affero General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #ifndef __MONOLITHIUM_VECTOR_H__
  21 #define __MONOLITHIUM_VECTOR_H__
  22
  23 #include "defs.h"
  24 #include "list.h"
  25
  26 #ifndef VECTOR_REALLOC
  27 extern void *realloc(void*, size_t);
  28 #define VECTOR_REALLOC(p, s) realloc((p), (s))
  29 #endif
  30
  31 typedef struct
  32 {
  33     void *address;
  34     size_t length;
  35 } vector_buffer_t;
  36
  37 typedef struct
  38 {
  39     list_entry_t link;
  40     vector_buffer_t buf;
  41 } vector_buffer_entry_t;
  42
  43 typedef struct
  44 {
  45     size_t position;
  46     size_t size;
  47     list_entry_t buffer_list;
  48 } vector_t;
  49
  50 static bool_t vector_insert_buffer(vector_t *vector, size_t position, const vector_buffer_t *buffer)
  51 {
  52     if (!buffer->length) return TRUE;
  53     list_entry_t *ptr = &vector->buffer_list;
  54
  55     while (position)
  56     {
  57         list_entry_t *next = ptr->next;
  58         if (next == &vector->buffer_list) return FALSE;
  59
  60         vector_buffer_entry_t *entry = CONTAINER_OF(next, vector_buffer_entry_t, link);
  61         if (entry->buf.length > position)
  62         {
  63             vector_buffer_entry_t *remaining = VECTOR_REALLOC(NULL, sizeof(vector_buffer_entry_t));
  64             if (!remaining) return FALSE;
  65
  66             remaining->buf.address = (void*)((uintptr_t)entry->buf.address + position);
  67             remaining->buf.length = entry->buf.length - position;
  68             entry->buf.length = position;
  69
  70             list_put_after(next, &remaining->link);
  71         }
  72
  73         position -= entry->buf.length;
  74         ptr = next;
  75     }
  76
  77     vector_buffer_entry_t *entry = VECTOR_REALLOC(NULL, sizeof(vector_buffer_entry_t));
  78     entry->buf = *buffer;
  79     list_put_after(ptr, &entry->link);
  80     vector->size += buffer->length;
  81     return TRUE;
  82 }
  83
  84 static inline void vector_clear(vector_t *vector)
  85 {
  86     vector->position = vector->size = 0;
  87
  88     while (vector->buffer_list.next != &vector->buffer_list)
  89     {
  90         list_entry_t *ptr = vector->buffer_list.next;
  91         list_remove(ptr);
  92         ptr = VECTOR_REALLOC(ptr, 0);
  93     }
  94 }
  95
  96 static inline bool_t vector_init(vector_t *vector, vector_buffer_t *buffers, size_t num_buffers)
  97 {
  98     vector->position = vector->size = 0;
  99     list_init(&vector->buffer_list);
 100
 101     int i;
 102     for (i = 0; i < num_buffers; i++)
 103     {
 104         if (!vector_insert_buffer(vector, vector->size, &buffers[i]))
 105         {
 106             vector_clear(vector);
 107             return FALSE;
 108         }
 109     }
 110
 111     return TRUE;
 112 }
 113
 114 static inline void vector_read_gather(vector_t *vector, void *data, size_t size)
 115 {
 116     size_t position = 0;
 117     list_entry_t *ptr;
 118
 119     for (ptr = vector->buffer_list.next; ptr != &vector->buffer_list && position < vector->position + size; ptr = ptr->next)
 120     {
 121         vector_buffer_t *buffer = &CONTAINER_OF(ptr, vector_buffer_entry_t, link)->buf;
 122         uintptr_t start = position > vector->position ? position : vector->position;
 123         uintptr_t end = position + buffer->length < vector->position + size ? position + buffer->length : vector->position + size;
 124
 125         if (start < end)
 126         {
 127             __builtin_memcpy((void*)((uintptr_t)data + start - vector->position),
 128                              (void*)((uintptr_t)buffer->address + start - position),
 129                              end - start);
 130         }
 131
 132         position += buffer->length;
 133     }
 134
 135     vector->position += size;
 136 }
 137
 138 static inline void vector_write_scatter(vector_t *vector, const void *data, size_t size)
 139 {
 140     size_t position = 0;
 141     list_entry_t *ptr;
 142
 143     for (ptr = vector->buffer_list.next; ptr != &vector->buffer_list && position < vector->position + size; ptr = ptr->next)
 144     {
 145         vector_buffer_t *buffer = &CONTAINER_OF(ptr, vector_buffer_entry_t, link)->buf;
 146         uintptr_t start = position > vector->position ? position : vector->position;
 147         uintptr_t end = position + buffer->length < vector->position + size ? position + buffer->length : vector->position + size;
 148
 149         if (start < end)
 150         {
 151             __builtin_memcpy((void*)((uintptr_t)buffer->address + start - position),
 152                              (void*)((uintptr_t)data + start - vector->position),
 153                              end - start);
 154         }
 155
 156         position += buffer->length;
 157     }
 158
 159     vector->position += size;
 160 }
 161
 162 static inline void vector_seek(vector_t *vector, size_t position)
 163 {
 164     vector->position = position < vector->size ? position : vector->size;
 165 }
 166
 167 #endif