rxvt-unicode/src/emman.c

/* enable mremap on GNU/Linux */
#ifdef __linux__
# undef _GNU_SOURCE
# define _GNU_SOURCE
#endif

/* enable the POSIX prototypes of mmap/munmap on Solaris */
#ifdef __sun
# if __STDC_VERSION__ >= 199901L
#  define _XOPEN_SOURCE 600
# else
#  define _XOPEN_SOURCE 500
# endif
#endif

#include "emman.h"

#include <ecb.h>

#include <string.h>

#ifndef _WIN32
# include <unistd.h>
#endif

#if _POSIX_MAPPED_FILES > 0
# define USE_MMAP 1
# include <sys/mman.h>
# ifndef MAP_FAILED
#  define MAP_FAILED ((void *)-1)
# endif
# ifndef MAP_ANONYMOUS
#  ifdef MAP_ANON
#   define MAP_ANONYMOUS MAP_ANON
#  else
#   undef USE_MMAP
#  endif
# endif
# include <limits.h>
# ifndef PAGESIZE
static uint32_t pagesize;
#  define BOOT_PAGESIZE if (!pagesize) pagesize = sysconf (_SC_PAGESIZE)
#  define PAGESIZE pagesize
# else
#  define BOOT_PAGESIZE
# endif
#else
# define PAGESIZE 1
# define BOOT_PAGESIZE
#endif

size_t
chunk_round (size_t size)
{
  BOOT_PAGESIZE;

  return (size + (PAGESIZE - 1)) & ~(size_t)(PAGESIZE - 1);
}

size_t
chunk_fit (size_t header, size_t element_size, size_t max_increase)
{
  uint32_t fill, maximum_fill = 0;
  size_t minimum_size;

  max_increase += header + element_size;

  BOOT_PAGESIZE;

  do
    {
      header += element_size;

      fill = (uint32_t)header & (PAGESIZE - 1);

      if (fill >= maximum_fill)
        {
          maximum_fill = fill + 16; /* size increase results in at least 16 bytes improvement */
          minimum_size = header;
        }
    }
  while (header < max_increase);

  return minimum_size;
}

void *
chunk_alloc (size_t size, int populate)
{
  #if USE_MMAP
    void *ptr = MAP_FAILED;
    
    #ifdef MAP_POPULATE
      if (populate & 1)
        ptr = mmap (0, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_POPULATE, -1, 0);
    #endif

    if (ptr == MAP_FAILED)
      ptr = mmap (0, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

    if (ptr == MAP_FAILED)
      return 0;

    return ptr;
  #else
    return malloc (size);
  #endif
}

void *
chunk_realloc (void *ptr, size_t old_size, size_t new_size)
{
  #if USE_MMAP
    #ifdef MREMAP_MAYMOVE /* requires _GNU_SOURCE */
      void *ptr2 = mremap (ptr, old_size, new_size, MREMAP_MAYMOVE);

      if (ptr2 == MAP_FAILED)
        return 0;

      return ptr2;
    #else
      void *ptr2 = chunk_alloc (new_size, 0);

      if (!ptr2)
        return ptr2;

      /* TODO: prepopulate old_size pages instead of faulting them in */

      memcpy (ptr2, ptr, old_size);
      munmap (ptr, old_size);
      return ptr2;
    #endif
  #else
    return realloc (ptr, new_size);
  #endif
}

void
chunk_free (void *ptr, size_t size)
{
  #if USE_MMAP
    /* we assume the OS never mmaps at address 0 */
    if (ptr)
      munmap (ptr, size);
  #else
    return free (ptr);
  #endif
}

Revision:	1.8
Committed:	Tue Jun 25 03:35:01 2019 UTC (4 years, 11 months ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rxvt-unicode-rel-9_29, rxvt-unicode-rel-9_26, rxvt-unicode-rel-9_25, rxvt-unicode-rel-9_30, HEAD
Changes since 1.7:	+1 -0 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	sf-exg	1.4	/* enable mremap on GNU/Linux */
2			#ifdef __linux__
3	root	1.8	# undef _GNU_SOURCE
4	sf-exg	1.4	# define _GNU_SOURCE
5			#endif
6
7			/* enable the POSIX prototypes of mmap/munmap on Solaris */
8			#ifdef __sun
9	sf-exg	1.5	# if __STDC_VERSION__ >= 199901L
10	sf-exg	1.4	# define _XOPEN_SOURCE 600
11			# else
12			# define _XOPEN_SOURCE 500
13			# endif
14			#endif
15
16	root	1.1	#include "emman.h"
17
18			#include <ecb.h>
19
20			#include <string.h>
21
22			#ifndef _WIN32
23			# include <unistd.h>
24			#endif
25
26	root	1.7	#if _POSIX_MAPPED_FILES > 0
27	root	1.1	# define USE_MMAP 1
28			# include <sys/mman.h>
29			# ifndef MAP_FAILED
30			# define MAP_FAILED ((void *)-1)
31			# endif
32			# ifndef MAP_ANONYMOUS
33			# ifdef MAP_ANON
34			# define MAP_ANONYMOUS MAP_ANON
35			# else
36			# undef USE_MMAP
37			# endif
38			# endif
39			# include <limits.h>
40			# ifndef PAGESIZE
41			static uint32_t pagesize;
42			# define BOOT_PAGESIZE if (!pagesize) pagesize = sysconf (_SC_PAGESIZE)
43			# define PAGESIZE pagesize
44			# else
45			# define BOOT_PAGESIZE
46			# endif
47			#else
48			# define PAGESIZE 1
49	root	1.6	# define BOOT_PAGESIZE
50	root	1.1	#endif
51
52			size_t
53			chunk_round (size_t size)
54			{
55			BOOT_PAGESIZE;
56
57			return (size + (PAGESIZE - 1)) & ~(size_t)(PAGESIZE - 1);
58			}
59
60			size_t
61			chunk_fit (size_t header, size_t element_size, size_t max_increase)
62			{
63			uint32_t fill, maximum_fill = 0;
64			size_t minimum_size;
65
66			max_increase += header + element_size;
67
68			BOOT_PAGESIZE;
69
70			do
71			{
72			header += element_size;
73
74			fill = (uint32_t)header & (PAGESIZE - 1);
75
76			if (fill >= maximum_fill)
77			{
78			maximum_fill = fill + 16; /* size increase results in at least 16 bytes improvement */
79			minimum_size = header;
80			}
81			}
82			while (header < max_increase);
83
84			return minimum_size;
85			}
86
87			void *
88			chunk_alloc (size_t size, int populate)
89			{
90			#if USE_MMAP
91			void *ptr = MAP_FAILED;
92
93			#ifdef MAP_POPULATE
94			if (populate & 1)
95			ptr = mmap (0, size, PROT_READ \| PROT_WRITE, MAP_PRIVATE \| MAP_ANONYMOUS \| MAP_POPULATE, -1, 0);
96			#endif
97
98			if (ptr == MAP_FAILED)
99			ptr = mmap (0, size, PROT_READ \| PROT_WRITE, MAP_PRIVATE \| MAP_ANONYMOUS, -1, 0);
100
101			if (ptr == MAP_FAILED)
102			return 0;
103
104			return ptr;
105			#else
106			return malloc (size);
107			#endif
108			}
109
110			void *
111			chunk_realloc (void *ptr, size_t old_size, size_t new_size)
112			{
113			#if USE_MMAP
114			#ifdef MREMAP_MAYMOVE /* requires _GNU_SOURCE */
115			void *ptr2 = mremap (ptr, old_size, new_size, MREMAP_MAYMOVE);
116
117			if (ptr2 == MAP_FAILED)
118			return 0;
119
120			return ptr2;
121			#else
122			void *ptr2 = chunk_alloc (new_size, 0);
123
124			if (!ptr2)
125			return ptr2;
126
127			/* TODO: prepopulate old_size pages instead of faulting them in */
128
129			memcpy (ptr2, ptr, old_size);
130			munmap (ptr, old_size);
131			return ptr2;
132			#endif
133			#else
134	sf-exg	1.3	return realloc (ptr, new_size);
135	root	1.1	#endif
136			}
137
138			void
139			chunk_free (void *ptr, size_t size)
140			{
141			#if USE_MMAP
142	root	1.2	/* we assume the OS never mmaps at address 0 */
143			if (ptr)
144			munmap (ptr, size);
145	root	1.1	#else
146			return free (ptr);
147			#endif
148			}
149