git.cworth.org Git - vogl/blob - src/voglcore/vogl_object_pool.cpp

   1 /**************************************************************************
   2  *
   3  * Copyright 2013-2014 RAD Game Tools and Valve Software
   4  * Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
   5  * All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a copy
   8  * of this software and associated documentation files (the "Software"), to deal
   9  * in the Software without restriction, including without limitation the rights
  10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11  * copies of the Software, and to permit persons to whom the Software is
  12  * furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included in
  15  * all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  20  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  23  * THE SOFTWARE.
  24  *
  25  **************************************************************************/
  26
  27 // File: vogl_object_pool.cpp
  28 #include "vogl_object_pool.h"
  29
  30 VOGL_NAMESPACE_BEGIN(vogl)
  31
  32 #define CHECK(x) \
  33     if (!(x))    \
  34         return false;
  35
  36 bool object_pool_test()
  37 {
  38     object_pool<uint, object_pool_spinlock_locking_policy> pool;
  39
  40     bool s = pool.check();
  41     CHECK(s);
  42
  43     uint *q = pool.alloc();
  44
  45     s = pool.check();
  46     CHECK(s);
  47
  48     pool.destroy(q);
  49
  50     s = pool.check();
  51     CHECK(s);
  52
  53     pool.clear();
  54     CHECK(s);
  55
  56     vogl::random rm;
  57
  58     vogl::vector<uint *> ptrs;
  59     uint z = 0;
  60     //for (uint t = 0; t < 10000; t++, z++)
  61     for (uint t = 0; t < 1000000; t++, z++)
  62     {
  63         printf("%u %" PRIu64 " %" PRIu64 "\n", t, (uint64_t)pool.get_total_blocks(), (uint64_t)pool.get_total_heap_bytes());
  64
  65         uint n = rm.irand(0, 1000);
  66         for (uint i = 0; i < n; i++)
  67         {
  68             ptrs.push_back(pool.alloc());
  69
  70             s = pool.is_valid_ptr(ptrs.back(), true);
  71             CHECK(s);
  72
  73             *ptrs.back() = ptrs.size() - 1;
  74         }
  75
  76         s = pool.check();
  77         CHECK(s);
  78
  79         object_pool<uint, object_pool_spinlock_locking_policy> other_pool;
  80
  81         other_pool.swap(pool);
  82         s = other_pool.check();
  83         CHECK(s);
  84         s = pool.check();
  85         CHECK(s);
  86
  87         pool.swap(other_pool);
  88         s = other_pool.check();
  89         CHECK(s);
  90         s = pool.check();
  91         CHECK(s);
  92
  93         pool.swap(other_pool);
  94         s = other_pool.check();
  95         CHECK(s);
  96         s = pool.check();
  97         CHECK(s);
  98
  99         pool.swap(other_pool);
 100         s = other_pool.check();
 101         CHECK(s);
 102         s = pool.check();
 103         CHECK(s);
 104
 105         uint d = rm.irand(0, 1100); //(z < 400) ? 100 : 1200);
 106         for (uint i = 0; i < d; i++)
 107         {
 108             if (ptrs.is_empty())
 109                 break;
 110
 111             uint k = rm.irand(0, ptrs.size());
 112
 113             uint *p = ptrs[k];
 114             VOGL_ASSERT(*p == k);
 115
 116             s = pool.is_valid_ptr(p);
 117             CHECK(s);
 118
 119             pool.destroy(p);
 120
 121             s = pool.is_valid_ptr(p, false);
 122             CHECK(s);
 123
 124             if (k != ptrs.size() - 1)
 125             {
 126                 ptrs[k] = ptrs.back();
 127                 *ptrs[k] = k;
 128             }
 129
 130             ptrs.pop_back();
 131         }
 132
 133         s = pool.check();
 134         CHECK(s);
 135
 136         if (!rm.irand(0, 4000))
 137         {
 138             for (uint i = 0; i < ptrs.size(); i++)
 139                 pool.destroy(ptrs[i]);
 140
 141             ptrs.clear();
 142             z = 0;
 143         }
 144
 145         size_t l = pool.free_unused_blocks();
 146         printf("Freed %" PRIu64 " bytes of unused blocks\n", (uint64_t)l);
 147
 148         s = pool.check();
 149         CHECK(s);
 150
 151         if (!rm.irand(0, 4000))
 152         {
 153             printf("reset 0\n");
 154
 155             for (uint i = 0; i < ptrs.size(); i++)
 156                 pool.destroy(ptrs[i]);
 157
 158             ptrs.clear();
 159             z = 0;
 160             pool.clear();
 161
 162             s = pool.check();
 163             CHECK(s);
 164         }
 165         if (!rm.irand(0, 4000))
 166         {
 167             printf("reset 1\n");
 168
 169             ptrs.clear();
 170             z = 0;
 171             pool.clear();
 172
 173             s = pool.check();
 174             CHECK(s);
 175         }
 176     }
 177
 178     return true;
 179 }
 180
 181 VOGL_NAMESPACE_END(vogl)