blob: e399508683a3c6fae6968276d305c335ad3c2030 (
plain)
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
/**
****************************************************************************************
*
* @file ke_mem.h
*
* @brief API for the heap management module.
*
* Copyright (C) RivieraWaves 2009-2015
*
*
****************************************************************************************
*/
#ifndef _KE_MEM_H_
#define _KE_MEM_H_
#include "rwip_config.h" // IP configuration
#include <stdint.h> // standard integer
#include <stdbool.h> // standard includes
/**
****************************************************************************************
* @defgroup MEM Memory
* @ingroup KERNEL
* @brief Heap management module.
*
* This module implements heap management functions that allow initializing heap,
* allocating and freeing memory.
*
* @{
****************************************************************************************
*/
// forward declarations
struct mblock_free;
/**
****************************************************************************************
* @brief Heap initialization.
*
* This function performs the following operations:
* - sanity checks
* - check memory allocated is at least large enough to hold two block descriptors to hold
* start and end
* - initialize the first and last descriptors
* - save heap into kernel environment variable.
*
* @param[in] type Memory type.
* @param[in|out] heap Heap pointer
* @param[in] heap_size Size of the heap
*
*
****************************************************************************************
*/
void ke_mem_init(uint8_t type, uint8_t* heap, uint16_t heap_size);
/**
****************************************************************************************
* @brief Allocation of a block of memory.
*
* Allocates a memory block whose size is size; if no memory is available return NULL
*
* @param[in] size Size of the memory area that need to be allocated.
* @param[in] type Type of memory block
*
* @return A pointer to the allocated memory area.
*
****************************************************************************************
*/
void *ke_malloc(uint32_t size, uint8_t type);
/**
****************************************************************************************
* @brief Check if it's possible to allocate a block of memory with a specific size.
*
* @param[in] size Size of the memory area that need to be allocated.
* @param[in] type Type of memory block
*
* @return True if memory block can be allocated, False else.
*
****************************************************************************************
*/
bool ke_check_malloc(uint32_t size, uint8_t type);
/**
****************************************************************************************
* @brief Freeing of a block of memory.
*
* Free the memory area pointed by mem_ptr : mark the block as free and insert it in
* the pool of free block.
*
* @param[in] mem_ptr Pointer to the memory area that need to be freed.
*
****************************************************************************************
*/
void ke_free(void *mem_ptr);
/**
****************************************************************************************
* @brief Check if current heap is empty or not (not used)
*
* @param[in] type Type of memory heap block
*
* @return true if heap not used, false else.
****************************************************************************************
*/
bool ke_mem_is_empty(uint8_t type);
/**
****************************************************************************************
* @brief Check if current pointer is free or not
*
* @param[in] mem_ptr pointer to a memory block
*
* @return true if already free, false else.
****************************************************************************************
*/
bool ke_is_free(void* mem_ptr);
#if (KE_PROFILING)
/**
****************************************************************************************
* @brief Retrieve memory usage of selected heap.
*
* @param[in] type Type of memory heap block
*
* @return current memory usage of current heap.
****************************************************************************************
*/
uint16_t ke_get_mem_usage(uint8_t type);
/**
****************************************************************************************
* @brief Retrieve max memory usage of all heap.
* This command also resets max measured value.
*
* @return max memory usage of all heap.
****************************************************************************************
*/
uint32_t ke_get_max_mem_usage(void);
#endif // (KE_PROFILING)
///@} MEM
#endif // _KE_MEM_H_
|
