libstdc++-v3/testsuite/20_util/monotonic_buffer_resource/allocate.cc

   1 // Copyright (C) 2018 Free Software Foundation, Inc.
   2 //
   3 // This file is part of the GNU ISO C++ Library.  This library is free
   4 // software; you can redistribute it and/or modify it under the
   5 // terms of the GNU General Public License as published by the
   6 // Free Software Foundation; either version 3, or (at your option)
   7 // any later version.
   8
   9 // This library is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13
  14 // You should have received a copy of the GNU General Public License along
  15 // with this library; see the file COPYING3.  If not see
  16 // <http://www.gnu.org/licenses/>.
  17
  18 // { dg-options "-std=gnu++17" }
  19 // { dg-do run { target c++17 } }
  20 // { dg-require-cstdint "" }
  21
  22 #include <memory_resource>
  23 #include <testsuite_allocator.h>
  24
  25 void
  26 test01()
  27 {
  28   __gnu_test::memory_resource r;
  29
  30   // test that it's possible to allocate after each of the constructors
  31   {
  32     std::pmr::monotonic_buffer_resource mr(&r);
  33     auto p = mr.allocate(1024);
  34     VERIFY( p != nullptr );
  35     auto q = mr.allocate(1024);
  36     VERIFY( q != nullptr );
  37     VERIFY( p != q );
  38   }
  39   VERIFY( r.number_of_active_allocations() == 0 );
  40   {
  41     std::pmr::monotonic_buffer_resource mr(128, &r);
  42     auto p = mr.allocate(1024);
  43     VERIFY( p != nullptr );
  44     auto q = mr.allocate(1024);
  45     VERIFY( q != nullptr );
  46     VERIFY( p != q );
  47   }
  48   VERIFY( r.number_of_active_allocations() == 0 );
  49   {
  50     unsigned char buf[64];
  51     std::pmr::monotonic_buffer_resource mr((void*)buf, sizeof(buf), &r);
  52     auto p = mr.allocate(1024);
  53     VERIFY( p != nullptr );
  54     auto q = mr.allocate(1024);
  55     VERIFY( q != nullptr );
  56     VERIFY( p != q );
  57   }
  58   VERIFY( r.number_of_active_allocations() == 0 );
  59   {
  60     std::pmr::monotonic_buffer_resource mr;
  61     auto p = mr.allocate(1024);
  62     VERIFY( p != nullptr );
  63     auto q = mr.allocate(1024);
  64     VERIFY( q != nullptr );
  65     VERIFY( p != q );
  66   }
  67   {
  68     std::pmr::monotonic_buffer_resource mr(64);
  69     auto p = mr.allocate(1024);
  70     VERIFY( p != nullptr );
  71     auto q = mr.allocate(1024);
  72     VERIFY( q != nullptr );
  73     VERIFY( p != q );
  74   }
  75   {
  76     unsigned char buf[64];
  77     std::pmr::monotonic_buffer_resource mr((void*)buf, sizeof(buf));
  78     auto p = mr.allocate(1024);
  79     VERIFY( p != nullptr );
  80     auto q = mr.allocate(1024);
  81     VERIFY( q != nullptr );
  82     VERIFY( p != q );
  83   }
  84 }
  85
  86 void
  87 test02()
  88 {
  89   unsigned char buf[64];
  90   std::pmr::monotonic_buffer_resource mr(buf, sizeof(buf));
  91
  92   auto p = mr.allocate(0);
  93   VERIFY( p != nullptr );
  94   auto q = mr.allocate(0);
  95   VERIFY( q != nullptr );
  96   VERIFY( p != q );
  97
  98   p = mr.allocate(0, 1);
  99   VERIFY( p != nullptr );
 100   q = mr.allocate(0, 1);
 101   VERIFY( q != nullptr );
 102   VERIFY( p != q );
 103 }
 104
 105 void
 106 test03()
 107 {
 108 #if __cpp_exceptions
 109   {
 110     std::pmr::monotonic_buffer_resource mr(std::pmr::null_memory_resource());
 111     bool caught = false;
 112     try
 113     {
 114       (void) mr.allocate(1, 1);
 115     }
 116     catch (const std::bad_alloc&)
 117     {
 118       caught = true;
 119     }
 120     VERIFY( caught );
 121   }
 122   {
 123     unsigned char buf[16];
 124     std::pmr::monotonic_buffer_resource mr(buf, sizeof(buf),
 125                                            std::pmr::null_memory_resource());
 126     (void) mr.allocate(16, 1);
 127     bool caught = false;
 128     try
 129     {
 130       (void) mr.allocate(1, 1);
 131     }
 132     catch (const std::bad_alloc&)
 133     {
 134       caught = true;
 135     }
 136     VERIFY( caught );
 137   }
 138 #endif
 139 }
 140
 141 void
 142 test04()
 143 {
 144   auto buf = new unsigned char[512];
 145   std::pmr::monotonic_buffer_resource mr(buf, 512,
 146                                          std::pmr::null_memory_resource());
 147   std::size_t prev_size = 1;
 148   void* prev_ptr = mr.allocate(prev_size, 1);
 149   for (int i = 0; i < 9; ++i)
 150   {
 151     std::size_t size = 1 << i;
 152     void* ptr = mr.allocate(size, 1);
 153     VERIFY( ((char*)ptr - (char*)prev_ptr) == prev_size );
 154     prev_ptr = ptr;
 155     prev_size = size;
 156   }
 157 }
 158
 159 void
 160 test05()
 161 {
 162   // test that returned pointer is correctly aligned
 163   auto is_aligned = [](void* p, size_t alignment) -> bool {
 164     return (reinterpret_cast<std::uintptr_t>(p) % alignment) == 0;
 165   };
 166
 167   auto buf = new unsigned char[2048];
 168   std::pmr::monotonic_buffer_resource mr(buf+1, 2047);
 169   for (int i = 0; i < 9; ++i)
 170   {
 171     auto p = mr.allocate(1, 1 << i);
 172     VERIFY( is_aligned(p, 1 << i) );
 173     // Make next available byte misaligned:
 174     (void) mr.allocate(1 << i, 1);
 175   }
 176 }
 177
 178 void
 179 test06()
 180 {
 181   // check for geometric progression in buffer sizes from upstream
 182
 183   struct resource : __gnu_test::memory_resource
 184   {
 185     bool allocated = false;
 186     std::size_t last_size = 0;
 187
 188     void*
 189     do_allocate(size_t bytes, size_t align) override
 190     {
 191       allocated = true;
 192       last_size = bytes;
 193       return __gnu_test::memory_resource::do_allocate(bytes, align);
 194     }
 195   };
 196
 197   resource r;
 198   std::pmr::monotonic_buffer_resource mr(32, &r);
 199   std::size_t last_size = 0;
 200
 201   for (int i = 0; i < 100; ++i)
 202   {
 203     (void) mr.allocate(16);
 204     if (r.allocated)
 205     {
 206       VERIFY(r.last_size >= last_size);
 207       last_size = r.last_size;
 208       r.allocated = false;
 209     }
 210   }
 211 }
 212
 213 int
 214 main()
 215 {
 216   test01();
 217   test02();
 218   test03();
 219   test04();
 220   test05();
 221   test06();
 222 }