-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathmemoryBuddy.c
497 lines (430 loc) · 16.5 KB
/
memoryBuddy.c
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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
/*****************************************************************
* Trochili RTOS Kernel *
* Copyright(C) 2015 LIUXUMING *
* www.trochili.com *
*****************************************************************/
#include <string.h>
#include "tcl.config.h"
#include "tcl.types.h"
#include "tcl.cpu.h"
#include "tcl.debug.h"
#include "tcl.mem.buddy.h"
#if ((TCL_MEMORY_ENABLE) && (TCL_MEMORY_BUDDY_ENABLE))
/* BUDDY属性标记定义 */
#define BUDDY_PROP_NONE (0x0) /* BUDDY空属性标记 */
#define BUDDY_PROP_READY (0x1<<0u) /* BUDDY就绪标记 */
#define PAGES_AVAIL (0x1<<7u)
#define PARENT_NODE(x) (((x) - 1u) / 2u)
#define LEFT_NODE(x) ((x) * 2u + 1u)
#define RIGHT_NODE(x) ((x) * 2u + 2u)
/* 调整x到和它最相近且不小于它的2的幂数 */
static TWord clp2(TWord x) {
x = x - 1U;
x = x | (x >> 1U);
x = x | (x >> 2U);
x = x | (x >> 4U);
x = x | (x >> 8U);
x = x | (x >> 16U);
return (x + 1U);
}
/* 调整x到和它最相近且不大于它的2的幂数 */
static TWord flp2(TWord x) {
x = x | (x >> 1U);
x = x | (x >> 2U);
x = x | (x >> 4U);
x = x | (x >> 8U);
x = x | (x >> 16U);
return (x - (x >> 1U));
}
/* 计算x以2为底的对数 */
static TWord log2(TWord x) {
TWord i = 0;
while (!(x &0x1)) {
i++;
x = x >> 1;
}
return i;
}
/* 计算2的x次幂 */
static TWord power2(TWord x)
{
TWord i = 1;
while (x)
{
i = i << 1;
x--;
}
return i;
}
/*****************************************************************
* 功能：分配每个二叉树节点管理的内存页数 *
* 参数：(1) pBuddy 伙伴系统分配器地址 *
* 返回: 无 *
* 说明： *
*****************************************************************/
static void BuildPageTree(TMemBuddy* pBuddy)
{
TIndex node;
U32 logn;
U32 x;
U32 y;
/* 计算树的节点总数 */
pBuddy->NodeNbr = pBuddy->PageNbr * 2u - 1u;
/* 计算每个节点管理的页数(采用以2为底的对数来表示) */
logn = log2(pBuddy->PageNbr) & 0x3f;
node = 0u;
for (y = 0; y <= logn; y++)
{
x = (pBuddy->PageNbr >> (logn - y));
while (x--)
{
pBuddy->NodeTags[node] = ((logn - y) | PAGES_AVAIL);
node++;
}
}
}
static int GetAvailPages(TMemBuddy* pBuddy)
{
TByte tag;
tag = pBuddy->NodeTags[0];
if (tag & PAGES_AVAIL)
{
return power2(tag & 0x3f);
}
return 0;
}
/*****************************************************************
* 功能：从伙伴管理器中分配一定数目的页 *
* 参数：(1) pBuddy 伙伴系统分配器对象地址 *
* (2) pages 需要分配的内存页数 *
* (3) index 分配得到的内存页号 *
* 返回: (1) 分配到的页面的编号 *
* 说明： *
*****************************************************************/
static TWord MallocPages(TMemBuddy* pBuddy, TWord pages)
{
TWord index;
TWord lvl;
TWord node;
TByte tag;
TByte logn;
TByte ltag;
TByte rtag;
TByte llogn;
TByte rlogn;
/* 计算和pages对应的以2为底的对数 */
logn = log2(pages);
/* 计算需要遍历的(从root算起)层数 */
lvl = log2(pBuddy->PageNbr) - logn;
/* 从根节点开始遍历lvl次，找到可供分配的节点 */
node = 0u;
while (lvl--)
{
tag = (pBuddy->NodeTags[LEFT_NODE(node)]);
if ((tag & PAGES_AVAIL) && ((tag & 0x3f) >= logn))
{
node = LEFT_NODE(node);
}
else
{
node = RIGHT_NODE(node);
}
}
/* 取消分配给该节点的内存页 */
pBuddy->NodeTags[node] = 0u;
/* 通过节点编号计算内存页编号 */
index = (node + 1u) * pages - pBuddy->PageNbr;
/* 回溯调整到根节点路径上的所有节点的可分配内存页数(注意是路径上的全部节点) */
while (node)
{
node = PARENT_NODE(node);
ltag = pBuddy->NodeTags[LEFT_NODE(node)];
rtag = pBuddy->NodeTags[RIGHT_NODE(node)];
if ((ltag & PAGES_AVAIL) && (rtag & PAGES_AVAIL))
{
llogn = (ltag & 0x3f);
rlogn = (rtag & 0x3f);
tag = (llogn > rlogn) ? llogn : rlogn;
tag |= PAGES_AVAIL;
}
else if (ltag & PAGES_AVAIL)
{
tag = ltag;
}
else if (rtag & PAGES_AVAIL)
{
tag = rtag;
}
else
{
tag = 0u;
}
pBuddy->NodeTags[node] = tag;
}
return index;
}
/*****************************************************************
* 功能：线程通用阻塞终止函数,将指定的线程从阻塞队列中终止阻塞 *
* 参数：(1) pBuddy 伙伴系统分配器对象地址 *
* (2) index 待释放的多个内存页的起始页号 *
* 返回: 无 *
* 说明： *
*****************************************************************/
static TWord FreePages(TMemBuddy* pBuddy, TWord index)
{
TWord pages;
TWord node;
TByte tag;
TByte logn;
TWord lvl;
TByte ltag;
TByte rtag;
TByte llogn;
TByte rlogn;
/* 计算根节点以2为底的对数 */
lvl = log2(pBuddy->PageNbr);
/* 通过内存页编号获得叶子节点编号 */
node = index + pBuddy->PageNbr - 1u;
/* 通过该叶子节点向上回溯查找分配该起始内存页的节点, 比对次数最多为树的深度 */
for (logn = 0; logn <= lvl; logn++)
{
/* 如果找到分配该内存(n)页的那个节点 */
if (!(pBuddy->NodeTags[node] & PAGES_AVAIL))
{
break;
}
node = PARENT_NODE(node);
}
/* 回收该相关内存(n)页,重新计算它可以管理的内存页数 */
pBuddy->NodeTags[node] = ((logn & 0x3f) | PAGES_AVAIL);
pages = power2(logn);
/* 尝试进行进行伙伴节点合并,需要一直遍历到root节点。
如果是根节点则不需要以下操作 */
while (node)
{
node = PARENT_NODE(node);
logn++;
ltag = pBuddy->NodeTags[LEFT_NODE(node)];
rtag = pBuddy->NodeTags[RIGHT_NODE(node)];
if ((ltag &PAGES_AVAIL) && (rtag &PAGES_AVAIL))
{
llogn = (ltag &0x3f);
rlogn = (rtag &0x3f);
if (power2(llogn) + power2(rlogn) == power2(logn))
{
tag = ((logn &0x3f) | PAGES_AVAIL);
}
else
{
tag = (llogn > rlogn) ? llogn : rlogn;
tag |= PAGES_AVAIL;
}
}
else if (ltag &PAGES_AVAIL)
{
tag = ltag;
}
else //if (rtag &PAGES_AVAIL)
{
tag = rtag;
}
pBuddy->NodeTags[node] = tag;
}
return pages;
}
/*****************************************************************
* 功能：初始化伙伴内存管理控制结构 *
* 参数：(1) pBuddy 伙伴系统分配器内存地址 *
* (2) pAddr 可供分配的内存地址 *
* (3) pagesize 内存页大小 *
* (4) pages 可供分配的内存页总数 *
* (5) pError 详细调用结果 *
* 返回: (1) eSuccess 操作成功 *
* (2) eFailure 操作失败 *
* 说明： *
*****************************************************************/
TState xBuddyInit(TMemBuddy* pBuddy, TChar* pAddr, TWord pages, TWord pagesize, TError* pError)
{
TState state = eFailure;
TError error = MEM_ERR_FAULT;
TIndex index;
TReg32 imask;
CpuEnterCritical(&imask);
if (!(pBuddy->Property & BUDDY_PROP_READY))
{
/* 调整pages到和它最相近且不大于它的2的幂数 */
pages = flp2(pages);
if (pages)
{
pBuddy->Property = BUDDY_PROP_READY;
pBuddy->PageAddr = pAddr;
pBuddy->PageSize = pagesize;
pBuddy->PageNbr = pages;
pBuddy->PageAvail = pages;
/* 设置所有内存都处于可分配状态 */
for (index = 0; index < MEM_BUDDY_PAGE_TAGS; index++)
{
pBuddy->PageTags[index] = ~0U;
}
/* 创建二叉树控制结构 */
BuildPageTree(pBuddy);
error = MEM_ERR_NONE;
state = eSuccess;
}
}
CpuLeaveCritical(imask);
*pError = error;
return state;
}
/*****************************************************************
* 功能：销毁伙伴内存管理控制结构 *
* 参数：(1) pBuddy 伙伴系统分配器内存地址 *
* (2) pError 详细调用结果 *
* 返回: (1) eSuccess 操作成功 *
* (2) eFailure 操作失败 *
* 说明： *
*****************************************************************/
TState xBuddyDeinit(TMemBuddy* pBuddy, TError* pError)
{
TReg32 imask;
TState state = eFailure;
TError error = MEM_ERR_UNREADY;
CpuEnterCritical(&imask);
if (pBuddy->Property & MEM_PROP_READY)
{
memset(pBuddy->PageAddr, 0u, pBuddy->PageSize * pBuddy->PageNbr);
memset(pBuddy, 0u, sizeof(TMemBuddy));
error = MEM_ERR_NONE;
state = eSuccess;
}
CpuLeaveCritical(imask);
*pError = error;
return state;
}
/*****************************************************************
* 功能：从伙伴系统中申请内存 *
* 参数：(1) pBuddy 伙伴系统分配器对象地址 *
* (2) len 需要分配的内存长度 *
* (3) pAddr2 分配得到的内存地址指针 *
* (4) pError 详细调用结果 *
* 返回: (1) eSuccess 操作成功 *
* (2) eFailure 操作失败 *
* 说明： *
*****************************************************************/
TState xBuddyMemMalloc(TMemBuddy* pBuddy, TWord length, void** pAddr2, TError* pError)
{
TState state = eFailure;
TError error = MEM_ERR_UNREADY;
TReg32 imask;
TWord pages;
TWord index;
TWord avail;
TIndex x;
TIndex y;
TIndex i;
CpuEnterCritical(&imask);
if (pBuddy->Property &BUDDY_PROP_READY)
{
/* 如果申请的内存长度没有超过BUDDY的范围 */
if (length <= (pBuddy->PageNbr * pBuddy->PageSize))
{
/* 计算需要分配多少内存页 */
pages = (length + pBuddy->PageSize - 1u) / (pBuddy->PageSize);
/* 调整pages到和它最相近且不小于它的2的幂数 */
pages = clp2(pages);
avail = GetAvailPages(pBuddy);
if (avail >= pages)
{
/* 获得分配的内存页编号 */
index = MallocPages(pBuddy, pages);
/* 标记该部分内存页已经被分配 */
for (i = 0; i < pages; i++)
{
y = ((index + i) >> 5);
x = ((index + i) & 0x1f);
pBuddy->PageTags[y] &= ~(0x1 << x);
}
pBuddy->PageAvail -= pages;
/* 通过内存页编号获得内存地址 */
*pAddr2 = (void*)(pBuddy->PageAddr + index * pBuddy->PageSize);
error = MEM_ERR_NONE;
state = eSuccess;
}
else
{
*pAddr2 = (void*)0;
error = MEM_ERR_NO_MEM;
}
}
else
{
error = MEM_ERR_NO_MEM;
}
}
CpuLeaveCritical(imask);
*pError = error;
return state;
}
/*****************************************************************
* 功能：向伙伴系统中释放内存 *
* 参数：(1) pBuddy 伙伴系统分配器对象地址 *
* (2) pAddr 待释放的内存地址 *
* (3) pError 详细调用结果 *
* 返回: (1) eSuccess 操作成功 *
* (2) eFailure 操作失败 *
* 说明： *
*****************************************************************/
TState xBuddyMemFree(TMemBuddy* pBuddy, void* pAddr, TError* pError)
{
TState state = eFailure;
TError error = MEM_ERR_UNREADY;
TReg32 imask;
TWord index;
TIndex x;
TIndex y;
TBitMask tag;
TWord pages;
TIndex i;
CpuEnterCritical(&imask);
if ((pBuddy->Property &BUDDY_PROP_READY))
{
/* 检查被释放的地址是否在伙伴系统管理的内存范围内 */
if (((char*)pAddr >= (char*)(pBuddy->PageAddr)) &&
((char*)pAddr < ((char*)(pBuddy->PageAddr) + pBuddy->PageSize* pBuddy->PageNbr)))
{
/* 通过内存地址计算起始页编号 */
index = ((char*)pAddr - (char*)(pBuddy->PageAddr)) / pBuddy->PageSize;
/* 检查内存页管理标记，避免再次释放已经释放过的内存页地址 */
y = (index >> 5);
x = (index & 0x1f);
tag = pBuddy->PageTags[y] & (0x1 << x);
if (tag == 0)
{
/* 释放该页起始的内存 */
pages = FreePages(pBuddy, index);
/* 标记该部分内存可以被分配 */
for (i = 0; i < pages; i++)
{
y = (index + i) >> 5;
x = (index + i) & 0x1f;
pBuddy->PageTags[y] |= (0x1 << x);
}
pBuddy->PageAvail += pages;
error = MEM_ERR_NONE;
state = eSuccess;
}
else
{
error = MEM_ERR_DBL_FREE;
}
}
else
{
error = MEM_ERR_BAD_ADDR;
}
}
CpuLeaveCritical(imask);
*pError = error;
return state;
}
#endif