2 * default memory allocator for libavutil
3 * Copyright (c) 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 * default memory allocator for libavutil
27 #define _XOPEN_SOURCE 600
34 #include <stdatomic.h>
40 #include "attributes.h"
45 #include "intreadwrite.h"
51 #define malloc AV_JOIN(MALLOC_PREFIX, malloc)
52 #define memalign AV_JOIN(MALLOC_PREFIX, memalign)
53 #define posix_memalign AV_JOIN(MALLOC_PREFIX, posix_memalign)
54 #define realloc AV_JOIN(MALLOC_PREFIX, realloc)
55 #define free AV_JOIN(MALLOC_PREFIX, free)
57 void *malloc(size_t size
);
58 void *memalign(size_t align
, size_t size
);
59 int posix_memalign(void **ptr
, size_t align
, size_t size
);
60 void *realloc(void *ptr
, size_t size
);
63 #endif /* MALLOC_PREFIX */
65 #define ALIGN (HAVE_AVX512 ? 64 : (HAVE_AVX ? 32 : 16))
67 /* NOTE: if you want to override these functions with your own
68 * implementations (not recommended) you have to link libav* as
69 * dynamic libraries and remove -Wl,-Bsymbolic from the linker flags.
70 * Note that this will cost performance. */
72 static atomic_size_t max_alloc_size
= ATOMIC_VAR_INIT(INT_MAX
);
74 void av_max_alloc(size_t max
){
75 atomic_store_explicit(&max_alloc_size
, max
, memory_order_relaxed
);
78 static int size_mult(size_t a
, size_t b
, size_t *r
)
82 #if (!defined(__INTEL_COMPILER) && AV_GCC_VERSION_AT_LEAST(5,1)) || AV_HAS_BUILTIN(__builtin_mul_overflow)
83 if (__builtin_mul_overflow(a
, b
, &t
))
84 return AVERROR(EINVAL
);
87 /* Hack inspired from glibc: don't try the division if nelem and elsize
88 * are both less than sqrt(SIZE_MAX). */
89 if ((a
| b
) >= ((size_t)1 << (sizeof(size_t) * 4)) && a
&& t
/ a
!= b
)
90 return AVERROR(EINVAL
);
96 void *av_malloc(size_t size
)
100 if (size
> atomic_load_explicit(&max_alloc_size
, memory_order_relaxed
))
103 #if HAVE_POSIX_MEMALIGN
104 if (size
) //OS X on SDK 10.6 has a broken posix_memalign implementation
105 if (posix_memalign(&ptr
, ALIGN
, size
))
107 #elif HAVE_ALIGNED_MALLOC
108 ptr
= _aligned_malloc(size
, ALIGN
);
111 ptr
= memalign(ALIGN
, size
);
113 ptr
= memalign(size
, ALIGN
);
116 * Indeed, we should align it:
119 * on 32 for 586, PPro - K6-III
120 * on 64 for K7 (maybe for P3 too).
121 * Because L1 and L2 caches are aligned on those values.
122 * But I don't want to code such logic here!
125 * For AVX ASM. SSE / NEON needs only 16.
126 * Why not larger? Because I did not see a difference in benchmarks ...
128 /* benchmarks with P3
129 * memalign(64) + 1 3071, 3051, 3032
130 * memalign(64) + 2 3051, 3032, 3041
131 * memalign(64) + 4 2911, 2896, 2915
132 * memalign(64) + 8 2545, 2554, 2550
133 * memalign(64) + 16 2543, 2572, 2563
134 * memalign(64) + 32 2546, 2545, 2571
135 * memalign(64) + 64 2570, 2533, 2558
137 * BTW, malloc seems to do 8-byte alignment by default here.
146 #if CONFIG_MEMORY_POISONING
148 memset(ptr
, FF_MEMORY_POISON
, size
);
153 void *av_realloc(void *ptr
, size_t size
)
156 if (size
> atomic_load_explicit(&max_alloc_size
, memory_order_relaxed
))
159 #if HAVE_ALIGNED_MALLOC
160 ret
= _aligned_realloc(ptr
, size
+ !size
, ALIGN
);
162 ret
= realloc(ptr
, size
+ !size
);
164 #if CONFIG_MEMORY_POISONING
166 memset(ret
, FF_MEMORY_POISON
, size
);
171 void *av_realloc_f(void *ptr
, size_t nelem
, size_t elsize
)
176 if (size_mult(elsize
, nelem
, &size
)) {
180 r
= av_realloc(ptr
, size
);
186 int av_reallocp(void *ptr
, size_t size
)
195 memcpy(&val
, ptr
, sizeof(val
));
196 val
= av_realloc(val
, size
);
200 return AVERROR(ENOMEM
);
203 memcpy(ptr
, &val
, sizeof(val
));
207 void *av_malloc_array(size_t nmemb
, size_t size
)
210 if (size_mult(nmemb
, size
, &result
) < 0)
212 return av_malloc(result
);
215 void *av_realloc_array(void *ptr
, size_t nmemb
, size_t size
)
218 if (size_mult(nmemb
, size
, &result
) < 0)
220 return av_realloc(ptr
, result
);
223 int av_reallocp_array(void *ptr
, size_t nmemb
, size_t size
)
227 memcpy(&val
, ptr
, sizeof(val
));
228 val
= av_realloc_f(val
, nmemb
, size
);
229 memcpy(ptr
, &val
, sizeof(val
));
230 if (!val
&& nmemb
&& size
)
231 return AVERROR(ENOMEM
);
236 void av_free(void *ptr
)
238 #if HAVE_ALIGNED_MALLOC
245 void av_freep(void *arg
)
249 memcpy(&val
, arg
, sizeof(val
));
250 memcpy(arg
, &(void *){ NULL
}, sizeof(val
));
254 void *av_mallocz(size_t size
)
256 void *ptr
= av_malloc(size
);
258 memset(ptr
, 0, size
);
262 void *av_calloc(size_t nmemb
, size_t size
)
265 if (size_mult(nmemb
, size
, &result
) < 0)
267 return av_mallocz(result
);
270 char *av_strdup(const char *s
)
274 size_t len
= strlen(s
) + 1;
275 ptr
= av_realloc(NULL
, len
);
282 char *av_strndup(const char *s
, size_t len
)
284 char *ret
= NULL
, *end
;
289 end
= memchr(s
, 0, len
);
293 ret
= av_realloc(NULL
, len
+ 1);
302 void *av_memdup(const void *p
, size_t size
)
306 ptr
= av_malloc(size
);
308 memcpy(ptr
, p
, size
);
313 int av_dynarray_add_nofree(void *tab_ptr
, int *nb_ptr
, void *elem
)
316 memcpy(&tab
, tab_ptr
, sizeof(tab
));
318 FF_DYNARRAY_ADD(INT_MAX
, sizeof(*tab
), tab
, *nb_ptr
, {
320 memcpy(tab_ptr
, &tab
, sizeof(tab
));
322 return AVERROR(ENOMEM
);
327 void av_dynarray_add(void *tab_ptr
, int *nb_ptr
, void *elem
)
330 memcpy(&tab
, tab_ptr
, sizeof(tab
));
332 FF_DYNARRAY_ADD(INT_MAX
, sizeof(*tab
), tab
, *nb_ptr
, {
334 memcpy(tab_ptr
, &tab
, sizeof(tab
));
341 void *av_dynarray2_add(void **tab_ptr
, int *nb_ptr
, size_t elem_size
,
342 const uint8_t *elem_data
)
344 uint8_t *tab_elem_data
= NULL
;
346 FF_DYNARRAY_ADD(INT_MAX
, elem_size
, *tab_ptr
, *nb_ptr
, {
347 tab_elem_data
= (uint8_t *)*tab_ptr
+ (*nb_ptr
) * elem_size
;
349 memcpy(tab_elem_data
, elem_data
, elem_size
);
350 else if (CONFIG_MEMORY_POISONING
)
351 memset(tab_elem_data
, FF_MEMORY_POISON
, elem_size
);
356 return tab_elem_data
;
359 static void fill16(uint8_t *dst
, int len
)
361 uint32_t v
= AV_RN16(dst
- 2);
377 static void fill24(uint8_t *dst
, int len
)
380 uint32_t v
= AV_RB24(dst
- 3);
381 uint32_t a
= v
<< 8 | v
>> 16;
382 uint32_t b
= v
<< 16 | v
>> 8;
383 uint32_t c
= v
<< 24 | v
;
385 uint32_t v
= AV_RL24(dst
- 3);
386 uint32_t a
= v
| v
<< 24;
387 uint32_t b
= v
>> 8 | v
<< 16;
388 uint32_t c
= v
>> 16 | v
<< 8;
417 static void fill32(uint8_t *dst
, int len
)
419 uint32_t v
= AV_RN32(dst
- 4);
422 uint64_t v2
= v
+ ((uint64_t)v
<<32);
445 void av_memcpy_backptr(uint8_t *dst
, int back
, int cnt
)
447 const uint8_t *src
= &dst
[-back
];
452 memset(dst
, *src
, cnt
);
453 } else if (back
== 2) {
455 } else if (back
== 3) {
457 } else if (back
== 4) {
462 while (cnt
> blocklen
) {
463 memcpy(dst
, src
, blocklen
);
468 memcpy(dst
, src
, cnt
);
472 AV_COPY32U(dst
, src
);
473 AV_COPY32U(dst
+ 4, src
+ 4);
479 AV_COPY32U(dst
, src
);
485 AV_COPY16U(dst
, src
);
495 void *av_fast_realloc(void *ptr
, unsigned int *size
, size_t min_size
)
499 if (min_size
<= *size
)
502 max_size
= atomic_load_explicit(&max_alloc_size
, memory_order_relaxed
);
503 /* *size is an unsigned, so the real maximum is <= UINT_MAX. */
504 max_size
= FFMIN(max_size
, UINT_MAX
);
506 if (min_size
> max_size
) {
511 min_size
= FFMIN(max_size
, FFMAX(min_size
+ min_size
/ 16 + 32, min_size
));
513 ptr
= av_realloc(ptr
, min_size
);
514 /* we could set this to the unmodified min_size but this is safer
515 * if the user lost the ptr and uses NULL now
525 static inline void fast_malloc(void *ptr
, unsigned int *size
, size_t min_size
, int zero_realloc
)
530 memcpy(&val
, ptr
, sizeof(val
));
531 if (min_size
<= *size
) {
532 av_assert0(val
|| !min_size
);
536 max_size
= atomic_load_explicit(&max_alloc_size
, memory_order_relaxed
);
537 /* *size is an unsigned, so the real maximum is <= UINT_MAX. */
538 max_size
= FFMIN(max_size
, UINT_MAX
);
540 if (min_size
> max_size
) {
545 min_size
= FFMIN(max_size
, FFMAX(min_size
+ min_size
/ 16 + 32, min_size
));
547 val
= zero_realloc
? av_mallocz(min_size
) : av_malloc(min_size
);
548 memcpy(ptr
, &val
, sizeof(val
));
555 void av_fast_malloc(void *ptr
, unsigned int *size
, size_t min_size
)
557 fast_malloc(ptr
, size
, min_size
, 0);
560 void av_fast_mallocz(void *ptr
, unsigned int *size
, size_t min_size
)
562 fast_malloc(ptr
, size
, min_size
, 1);
565 int av_size_mult(size_t a
, size_t b
, size_t *r
)
567 return size_mult(a
, b
, r
);