1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
//------------------------------------------------------------------------------
// GB_malloc_memory: wrapper for malloc
//------------------------------------------------------------------------------
// SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2025, All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
//------------------------------------------------------------------------------
// A wrapper for malloc. Space is not initialized.
#include "GB.h"
//------------------------------------------------------------------------------
// GB_malloc_helper: use malloc to allocate an uninitialized memory block
//------------------------------------------------------------------------------
static inline void *GB_malloc_helper
(
// input/output:
size_t *size // on input: # of bytes requested
// on output: # of bytes actually allocated
)
{
void *p = NULL ;
// make sure the block is at least 8 bytes in size
(*size) = GB_IMAX (*size, 8) ;
p = GB_Global_malloc_function (*size) ;
#ifdef GB_MEMDUMP
GBMDUMP ("malloc %p %8ld: ", p, *size) ;
GB_Global_memtable_dump ( ) ;
#endif
return (p) ;
}
//------------------------------------------------------------------------------
// GB_malloc_memory
//------------------------------------------------------------------------------
#if 0
void *GB_malloc_memory // pointer to allocated block of memory
(
size_t nitems, // number of items to allocate
size_t size_of_item, // sizeof each item
// output:
size_t *size_allocated // # of bytes actually allocated
)
#endif
GB_CALLBACK_MALLOC_MEMORY_PROTO (GB_malloc_memory)
{
//--------------------------------------------------------------------------
// check inputs
//--------------------------------------------------------------------------
ASSERT (size_allocated != NULL) ;
void *p ;
size_t size ;
// make sure at least one item is allocated
nitems = GB_IMAX (1, nitems) ;
// make sure at least one byte is allocated
size_of_item = GB_IMAX (1, size_of_item) ;
bool ok = GB_size_t_multiply (&size, nitems, size_of_item) ;
if (!ok || (((uint64_t) nitems) > GB_NMAX)
|| (((uint64_t) size_of_item) > GB_NMAX))
{
// overflow
(*size_allocated) = 0 ;
return (NULL) ;
}
//--------------------------------------------------------------------------
// allocate the memory block
//--------------------------------------------------------------------------
if (GB_Global_malloc_tracking_get ( ))
{
//----------------------------------------------------------------------
// for memory usage testing only
//----------------------------------------------------------------------
// brutal memory debug; pretend to fail if (count-- <= 0).
bool pretend_to_fail = false ;
if (GB_Global_malloc_debug_get ( ))
{
pretend_to_fail = GB_Global_malloc_debug_count_decrement ( ) ;
}
// allocate the memory
if (pretend_to_fail)
{
p = NULL ;
}
else
{
p = GB_malloc_helper (&size) ;
}
}
else
{
//----------------------------------------------------------------------
// normal use, in production
//----------------------------------------------------------------------
p = GB_malloc_helper (&size) ;
}
//--------------------------------------------------------------------------
// return result
//--------------------------------------------------------------------------
(*size_allocated) = (p == NULL) ? 0 : size ;
ASSERT (GB_IMPLIES (p != NULL, size == GB_Global_memtable_size (p))) ;
return (p) ;
}
|
