GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

microsoft/qdk

Public

mirrored from https://github.com/microsoft/qdkAvailable

Watch0Fork0Star0
CodeCommitsIssuesPull requestsActionsInsightsSecurity
92f542e70a6ca4eadffcee9e2e42c59c8f02df49

Branches

Tags

  • No tags available.
0Branches0Tags
Go to file
Add file
Code

Clone

HTTPS

Download ZIP

qdk/source/allocator/mimalloc-sys/mimalloc/src

source/allocator/mimalloc-sys/mimalloc/src/alloc-posix.c

185lines · modeblame

RawDownload
Latest commit unavailable.
91589c3aIan Davis2 years ago1/* ----------------------------------------------------------------------------
2Copyright (c) 2018-2021, Microsoft Research, Daan Leijen
3This is free software; you can redistribute it and/or modify it under the
4terms of the MIT license. A copy of the license can be found in the file
5"LICENSE" at the root of this distribution.
6-----------------------------------------------------------------------------*/
7
8// ------------------------------------------------------------------------
9// mi prefixed publi definitions of various Posix, Unix, and C++ functions
10// for convenience and used when overriding these functions.
11// ------------------------------------------------------------------------
12#include "mimalloc.h"
13#include "mimalloc/internal.h"
14
15// ------------------------------------------------------
16// Posix & Unix functions definitions
17// ------------------------------------------------------
18
19#include <errno.h>
20#include <string.h> // memset
21#include <stdlib.h> // getenv
22
23#ifdef _MSC_VER
24#pragma warning(disable:4996) // getenv _wgetenv
25#endif
26
27#ifndef EINVAL
28#define EINVAL 22
29#endif
30#ifndef ENOMEM
31#define ENOMEM 12
32#endif
33
34
35mi_decl_nodiscard size_t mi_malloc_size(const void* p) mi_attr_noexcept {
36// if (!mi_is_in_heap_region(p)) return 0;
37return mi_usable_size(p);
38}
39
40mi_decl_nodiscard size_t mi_malloc_usable_size(const void *p) mi_attr_noexcept {
41// if (!mi_is_in_heap_region(p)) return 0;
42return mi_usable_size(p);
43}
44
45mi_decl_nodiscard size_t mi_malloc_good_size(size_t size) mi_attr_noexcept {
46return mi_good_size(size);
47}
48
49void mi_cfree(void* p) mi_attr_noexcept {
50if (mi_is_in_heap_region(p)) {
51mi_free(p);
52}
53}
54
55int mi_posix_memalign(void** p, size_t alignment, size_t size) mi_attr_noexcept {
56// Note: The spec dictates we should not modify `*p` on an error. (issue#27)
57// <http://man7.org/linux/man-pages/man3/posix_memalign.3.html>
58if (p == NULL) return EINVAL;
59if ((alignment % sizeof(void*)) != 0) return EINVAL; // natural alignment
60// it is also required that alignment is a power of 2 and > 0; this is checked in `mi_malloc_aligned`
61if (alignment==0 || !_mi_is_power_of_two(alignment)) return EINVAL; // not a power of 2
62void* q = mi_malloc_aligned(size, alignment);
63if (q==NULL && size != 0) return ENOMEM;
64mi_assert_internal(((uintptr_t)q % alignment) == 0);
65*p = q;
66return 0;
67}
68
69mi_decl_nodiscard mi_decl_restrict void* mi_memalign(size_t alignment, size_t size) mi_attr_noexcept {
70void* p = mi_malloc_aligned(size, alignment);
71mi_assert_internal(((uintptr_t)p % alignment) == 0);
72return p;
73}
74
75mi_decl_nodiscard mi_decl_restrict void* mi_valloc(size_t size) mi_attr_noexcept {
76return mi_memalign( _mi_os_page_size(), size );
77}
78
79mi_decl_nodiscard mi_decl_restrict void* mi_pvalloc(size_t size) mi_attr_noexcept {
80size_t psize = _mi_os_page_size();
81if (size >= SIZE_MAX - psize) return NULL; // overflow
82size_t asize = _mi_align_up(size, psize);
83return mi_malloc_aligned(asize, psize);
84}
85
86mi_decl_nodiscard mi_decl_restrict void* mi_aligned_alloc(size_t alignment, size_t size) mi_attr_noexcept {
87// C11 requires the size to be an integral multiple of the alignment, see <https://en.cppreference.com/w/c/memory/aligned_alloc>.
88// unfortunately, it turns out quite some programs pass a size that is not an integral multiple so skip this check..
89/* if mi_unlikely((size & (alignment - 1)) != 0) { // C11 requires alignment>0 && integral multiple, see <https://en.cppreference.com/w/c/memory/aligned_alloc>
90#if MI_DEBUG > 0
91_mi_error_message(EOVERFLOW, "(mi_)aligned_alloc requires the size to be an integral multiple of the alignment (size %zu, alignment %zu)\n", size, alignment);
92#endif
93return NULL;
94}
95*/
96// C11 also requires alignment to be a power-of-two (and > 0) which is checked in mi_malloc_aligned
97void* p = mi_malloc_aligned(size, alignment);
98mi_assert_internal(((uintptr_t)p % alignment) == 0);
99return p;
100}
101
102mi_decl_nodiscard void* mi_reallocarray( void* p, size_t count, size_t size ) mi_attr_noexcept { // BSD
103void* newp = mi_reallocn(p,count,size);
104if (newp==NULL) { errno = ENOMEM; }
105return newp;
106}
107
108mi_decl_nodiscard int mi_reallocarr( void* p, size_t count, size_t size ) mi_attr_noexcept { // NetBSD
109mi_assert(p != NULL);
110if (p == NULL) {
111errno = EINVAL;
112return EINVAL;
113}
114void** op = (void**)p;
115void* newp = mi_reallocarray(*op, count, size);
116if mi_unlikely(newp == NULL) { return errno; }
117*op = newp;
118return 0;
119}
120
121void* mi__expand(void* p, size_t newsize) mi_attr_noexcept { // Microsoft
122void* res = mi_expand(p, newsize);
123if (res == NULL) { errno = ENOMEM; }
124return res;
125}
126
127mi_decl_nodiscard mi_decl_restrict unsigned short* mi_wcsdup(const unsigned short* s) mi_attr_noexcept {
128if (s==NULL) return NULL;
129size_t len;
130for(len = 0; s[len] != 0; len++) { }
131size_t size = (len+1)*sizeof(unsigned short);
132unsigned short* p = (unsigned short*)mi_malloc(size);
133if (p != NULL) {
134_mi_memcpy(p,s,size);
135}
136return p;
137}
138
139mi_decl_nodiscard mi_decl_restrict unsigned char* mi_mbsdup(const unsigned char* s) mi_attr_noexcept {
140return (unsigned char*)mi_strdup((const char*)s);
141}
142
143int mi_dupenv_s(char** buf, size_t* size, const char* name) mi_attr_noexcept {
144if (buf==NULL || name==NULL) return EINVAL;
145if (size != NULL) *size = 0;
146char* p = getenv(name); // mscver warning 4996
147if (p==NULL) {
148*buf = NULL;
149}
150else {
151*buf = mi_strdup(p);
152if (*buf==NULL) return ENOMEM;
153if (size != NULL) *size = _mi_strlen(p);
154}
155return 0;
156}
157
158int mi_wdupenv_s(unsigned short** buf, size_t* size, const unsigned short* name) mi_attr_noexcept {
159if (buf==NULL || name==NULL) return EINVAL;
160if (size != NULL) *size = 0;
161#if !defined(_WIN32) || (defined(WINAPI_FAMILY) && (WINAPI_FAMILY != WINAPI_FAMILY_DESKTOP_APP))
162// not supported
163*buf = NULL;
164return EINVAL;
165#else
166unsigned short* p = (unsigned short*)_wgetenv((const wchar_t*)name); // msvc warning 4996
167if (p==NULL) {
168*buf = NULL;
169}
170else {
171*buf = mi_wcsdup(p);
172if (*buf==NULL) return ENOMEM;
173if (size != NULL) *size = wcslen((const wchar_t*)p);
174}
175return 0;
176#endif
177}
178
179mi_decl_nodiscard void* mi_aligned_offset_recalloc(void* p, size_t newcount, size_t size, size_t alignment, size_t offset) mi_attr_noexcept { // Microsoft
180return mi_recalloc_aligned_at(p, newcount, size, alignment, offset);
181}
182
183mi_decl_nodiscard void* mi_aligned_recalloc(void* p, size_t newcount, size_t size, size_t alignment) mi_attr_noexcept { // Microsoft
184return mi_recalloc_aligned(p, newcount, size, alignment);
185}