visus
/
toolchain-gcc-arm-embedded
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commits
1 Branch
Tree: 898a39b5ab
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '898a39b5ab'
${ noResults }
toolchain-gcc-arm-embedded/lib/gcc/arm-none-eabi/10.2.1/plugin/include/memory-block.h

85 lines
2.4KB
Raw Blame History 

  1. /* Shared pool of memory blocks for pool allocators.

  2.    Copyright (C) 2015-2020 Free Software Foundation, Inc.

  3. 

  4. This file is part of GCC.

  5. 

  6. GCC is free software; you can redistribute it and/or modify

  7. it under the terms of the GNU General Public License as published by

  8. the Free Software Foundation; either version 3, or (at your option)

  9. any later version.

  10. 

  11. GCC 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 General Public License for more details.

  15. 

  16. You should have received a copy of the GNU General Public License

  17. along with GCC; see the file COPYING3.  If not see

  18. <http://www.gnu.org/licenses/>.  */

  19. 

  20. 

  21. #ifndef MEMORY_BLOCK_H

  22. #define MEMORY_BLOCK_H

  23. 

  24. /* Shared pool which allows other memory pools to reuse each others' allocated

  25.    memory blocks instead of calling free/malloc again.  */

  26. class memory_block_pool

  27. {

  28. public:

  29.   /* Blocks have fixed size.  This is necessary for sharing.  */

  30.   static const size_t block_size = 64 * 1024;

  31.   /* Number of blocks we keep in the freelists.  */

  32.   static const size_t freelist_size = 1024 * 1024 / block_size;

  33. 

  34.   memory_block_pool ();

  35. 

  36.   static inline void *allocate () ATTRIBUTE_MALLOC;

  37.   static inline void release (void *);

  38.   static void trim (int nblocks = freelist_size);

  39.   void reduce_free_list (int);

  40. 

  41. private:

  42.   /* memory_block_pool singleton instance, defined in memory-block.cc.  */

  43.   static memory_block_pool instance;

  44. 

  45.   struct block_list

  46.   {

  47.     block_list *m_next;

  48.   };

  49. 

  50.   /* Free list.  */

  51.   block_list *m_blocks;

  52. };

  53. 

  54. /* Allocate a single block.  Reuse a previously returned block, if possible.  */

  55. inline void *

  56. memory_block_pool::allocate ()

  57. {

  58.   if (instance.m_blocks == NULL)

  59.     return XNEWVEC (char, block_size);

  60. 

  61.   void *result = instance.m_blocks;

  62.   instance.m_blocks = instance.m_blocks->m_next;

  63.   VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (result, block_size));

  64.   return result;

  65. }

  66. 

  67. /* Return UNCAST_BLOCK to the pool.  */

  68. inline void

  69. memory_block_pool::release (void *uncast_block)

  70. {

  71.   block_list *block = new (uncast_block) block_list;

  72.   block->m_next = instance.m_blocks;

  73.   instance.m_blocks = block;

  74. 

  75.   VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS ((char *)uncast_block

  76. 						+ sizeof (block_list),

  77. 						block_size

  78. 						- sizeof (block_list)));

  79. }

  80. 

  81. extern void *mempool_obstack_chunk_alloc (size_t) ATTRIBUTE_MALLOC;

  82. extern void mempool_obstack_chunk_free (void *);

  83. 

  84. #endif /* MEMORY_BLOCK_H */