framework/delibs/decpp/deArrayBuffer.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements C++ Base Library
   3  * -----------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Array buffer
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "deArrayBuffer.hpp"
  25
  26 #if defined(DE_VALGRIND_BUILD) && defined(HAVE_VALGRIND_MEMCHECK_H)
  27 #       include <valgrind/memcheck.h>
  28 #endif
  29
  30 namespace de
  31 {
  32 namespace detail
  33 {
  34
  35 void* ArrayBuffer_AlignedMalloc (size_t numBytes, size_t alignment)
  36 {
  37         const int       sizeAsInt       = (int)numBytes;
  38         void*           ptr;
  39
  40         // int overflow
  41         if (sizeAsInt < 0 || numBytes != (size_t)sizeAsInt)
  42                 throw std::bad_alloc();
  43
  44         // alloc
  45         ptr = deAlignedMalloc(sizeAsInt, (int)alignment);
  46         if (!ptr)
  47                 throw std::bad_alloc();
  48
  49         // mark area as undefined for valgrind
  50 #if defined(DE_VALGRIND_BUILD) && defined(HAVE_VALGRIND_MEMCHECK_H)
  51         if (RUNNING_ON_VALGRIND)
  52         {
  53                 VALGRIND_MAKE_MEM_UNDEFINED(ptr, numBytes);
  54         }
  55 #endif
  56
  57         return ptr;
  58 }
  59
  60 void ArrayBuffer_AlignedFree (void* ptr)
  61 {
  62         deAlignedFree(ptr);
  63 }
  64
  65 } // detail
  66
  67 void ArrayBuffer_selfTest (void)
  68 {
  69         // default constructor
  70         {
  71                 de::ArrayBuffer<int> buf;
  72                 DE_TEST_ASSERT(buf.size() == 0);
  73                 DE_TEST_ASSERT(buf.getPtr() == DE_NULL);
  74         }
  75
  76         // sized constructor
  77         {
  78                 de::ArrayBuffer<int> buf(4);
  79                 DE_TEST_ASSERT(buf.size() == 4);
  80                 DE_TEST_ASSERT(buf.getPtr() != DE_NULL);
  81         }
  82
  83         // copy constructor
  84         {
  85                 de::ArrayBuffer<int> originalBuf(4);
  86                 *originalBuf.getElementPtr(0) = 1;
  87                 *originalBuf.getElementPtr(1) = 2;
  88                 *originalBuf.getElementPtr(2) = 3;
  89                 *originalBuf.getElementPtr(3) = 4;
  90
  91                 de::ArrayBuffer<int> targetBuf(originalBuf);
  92
  93                 DE_TEST_ASSERT(*originalBuf.getElementPtr(0) == 1);
  94                 DE_TEST_ASSERT(*originalBuf.getElementPtr(1) == 2);
  95                 DE_TEST_ASSERT(*originalBuf.getElementPtr(2) == 3);
  96                 DE_TEST_ASSERT(*originalBuf.getElementPtr(3) == 4);
  97
  98                 DE_TEST_ASSERT(*targetBuf.getElementPtr(0) == 1);
  99                 DE_TEST_ASSERT(*targetBuf.getElementPtr(1) == 2);
 100                 DE_TEST_ASSERT(*targetBuf.getElementPtr(2) == 3);
 101                 DE_TEST_ASSERT(*targetBuf.getElementPtr(3) == 4);
 102         }
 103
 104         // assignment
 105         {
 106                 de::ArrayBuffer<int> originalBuf(4);
 107                 *originalBuf.getElementPtr(0) = 1;
 108                 *originalBuf.getElementPtr(1) = 2;
 109                 *originalBuf.getElementPtr(2) = 3;
 110                 *originalBuf.getElementPtr(3) = 4;
 111
 112                 de::ArrayBuffer<int> targetBuf(1);
 113
 114                 targetBuf = originalBuf;
 115
 116                 DE_TEST_ASSERT(*originalBuf.getElementPtr(0) == 1);
 117                 DE_TEST_ASSERT(*originalBuf.getElementPtr(1) == 2);
 118                 DE_TEST_ASSERT(*originalBuf.getElementPtr(2) == 3);
 119                 DE_TEST_ASSERT(*originalBuf.getElementPtr(3) == 4);
 120
 121                 DE_TEST_ASSERT(*targetBuf.getElementPtr(0) == 1);
 122                 DE_TEST_ASSERT(*targetBuf.getElementPtr(1) == 2);
 123                 DE_TEST_ASSERT(*targetBuf.getElementPtr(2) == 3);
 124                 DE_TEST_ASSERT(*targetBuf.getElementPtr(3) == 4);
 125         }
 126
 127         // clear
 128         {
 129                 de::ArrayBuffer<int> buf(4);
 130                 buf.clear();
 131                 DE_TEST_ASSERT(buf.size() == 0);
 132                 DE_TEST_ASSERT(buf.getPtr() == DE_NULL);
 133         }
 134
 135         // setStorage
 136         {
 137                 de::ArrayBuffer<int> buf(4);
 138                 buf.setStorage(12);
 139                 DE_TEST_ASSERT(buf.size() == 12);
 140                 DE_TEST_ASSERT(buf.getPtr() != DE_NULL);
 141         }
 142
 143         // setStorage, too large
 144         {
 145                 de::ArrayBuffer<int> buf(4);
 146                 *buf.getElementPtr(0) = 1;
 147                 *buf.getElementPtr(1) = 2;
 148                 *buf.getElementPtr(2) = 3;
 149                 *buf.getElementPtr(3) = 4;
 150
 151                 try
 152                 {
 153                         buf.setStorage((size_t)-1);
 154
 155                         // setStorage succeeded, all ok
 156                 }
 157                 catch (std::bad_alloc&)
 158                 {
 159                         // alloc failed, check storage not changed
 160
 161                         DE_TEST_ASSERT(buf.size() == 4);
 162                         DE_TEST_ASSERT(*buf.getElementPtr(0) == 1);
 163                         DE_TEST_ASSERT(*buf.getElementPtr(1) == 2);
 164                         DE_TEST_ASSERT(*buf.getElementPtr(2) == 3);
 165                         DE_TEST_ASSERT(*buf.getElementPtr(3) == 4);
 166                 }
 167         }
 168
 169         // swap
 170         {
 171                 de::ArrayBuffer<int> buf;
 172                 de::ArrayBuffer<int> source(4);
 173                 *source.getElementPtr(0) = 1;
 174                 *source.getElementPtr(1) = 2;
 175                 *source.getElementPtr(2) = 3;
 176                 *source.getElementPtr(3) = 4;
 177
 178                 buf.swap(source);
 179
 180                 DE_TEST_ASSERT(source.size() == 0);
 181                 DE_TEST_ASSERT(buf.size() == 4);
 182                 DE_TEST_ASSERT(*buf.getElementPtr(0) == 1);
 183                 DE_TEST_ASSERT(*buf.getElementPtr(1) == 2);
 184                 DE_TEST_ASSERT(*buf.getElementPtr(2) == 3);
 185                 DE_TEST_ASSERT(*buf.getElementPtr(3) == 4);
 186         }
 187
 188         // default
 189         {
 190                 de::ArrayBuffer<int> source(4);
 191                 int dst;
 192                 *source.getElementPtr(1) = 2;
 193
 194                 deMemcpy(&dst, (int*)source.getPtr() + 1, sizeof(int));
 195
 196                 DE_TEST_ASSERT(dst == 2);
 197         }
 198
 199         // Aligned
 200         {
 201                 de::ArrayBuffer<int, 64, sizeof(int)> source(4);
 202                 int dst;
 203                 *source.getElementPtr(1) = 2;
 204
 205                 deMemcpy(&dst, (int*)source.getPtr() + 1, sizeof(int));
 206
 207                 DE_TEST_ASSERT(dst == 2);
 208         }
 209
 210         // Strided
 211         {
 212                 de::ArrayBuffer<int, 4, 64> source(4);
 213                 int dst;
 214                 *source.getElementPtr(1) = 2;
 215
 216                 deMemcpy(&dst, (deUint8*)source.getPtr() + 64, sizeof(int));
 217
 218                 DE_TEST_ASSERT(dst == 2);
 219         }
 220
 221         // Aligned, Strided
 222         {
 223                 de::ArrayBuffer<int, 32, 64> source(4);
 224                 int dst;
 225                 *source.getElementPtr(1) = 2;
 226
 227                 deMemcpy(&dst, (deUint8*)source.getPtr() + 64, sizeof(int));
 228
 229                 DE_TEST_ASSERT(dst == 2);
 230         }
 231 }
 232
 233 } // de